Design Frage

Firefighter

Auf jedenfall schonmal ein interessanter Beitrag, jedoch sicherlich nicht das ganze was ich brauche. Schließlich soll es möglich sein, das man unabhängige Instanzen von Holder oder Dummy erzeugen kann Aber ich versuche mal mein Glück mit den Accesoiren.Danke

Firefighter schrieb:

... Schließlich soll es möglich sein, das man unabhängige Instanzen von Holder oder Dummy erzeugen kann ...

Hehe, dann kannst du die Klasse ja public machen, aber trotzdem eingenestet lassen.

Acter.Dummy test = new Acter.Dummy();

Allerdings wirst du hier wiederum das Problem haben, dass nun die ganzen Properties wieder sichtbar werden... :-)!

Ich denke, so wie du es dir gedacht hast, ist es nicht so einfach möglich, wär aber ne interessante Aufgabe :-)!

Grüße

Firefighter

Hehe Stimmt, könnte man machen, würde dann aber dem Nested Prinzip widersprechen, denke ich:) Nun gut, dann muss ich den unschönen Weg gehen, ich dachte es gäbe einen bekannten Workarround oder ein Pattern, da ich keins der mir bekannten darauf anwendbar sah.Aber danke trotzdem für deine Antworten.

Die Lösung wurde doch schon genannt: internal.

Firefighters zweites Posting beinhaltet keinen Grund dagegen.

Andorxor

Du könntest das so lösen:

class Dummy
{
	private int wichtigevariable;

	public Dumm()
	{

	}

        public int WV
        {
          get{return wichtigevariable;}
          set
          {
             if(Acter.WVEditErlaubt)
             {
              wichtigevariable =value;
             }
          }
        }

}
class Holder
{
	private Dummy dummy;

	public Holder()
	{
		//...was mit dem Dummy
	}
}
class Acter
{
	private Dictionary<int,Holder> dummys;
        private static bool _WVEditErlaubt=false;

        public bool WVEditErlaubt
        {
           get{return _WVEditErlaubt;}
        }

	public Acter()
 	{
		//....
	}
	public void erhoehen(/*irgendwelche parameter*/)
	{
                 _WVEditErlaubt=true;
		//hier muss was mit der variable von Dummy gemacht werden
                _WVEditErlaubt = false;
	}
}

Shade Of Mine

Ich sehe das Problem nicht.

Wenn du nicht willst dass man den Dummy von Actor ändern kann, dann lass Actor immer ein readonly view von Dummy hergeben.

internal ist dann gut wenn niemand ein Dummy kennen können soll - aber das ist wieder ein komplett anderer weg.

Shade Of Mine schrieb:

Ich sehe das Problem nicht.

Wenn du nicht willst dass man den Dummy von Actor ändern kann, dann lass Actor immer ein readonly view von Dummy hergeben.

internal ist dann gut wenn niemand ein Dummy kennen können soll - aber das ist wieder ein komplett anderer weg.

public class Dummy {
    internal int p_WichtigeVariable;

    public void Dumm() {
      //... 
    }
  }

Nicht die Klasse "internal" machen, sondern den Member.

Hallo,

"internal" geht nur, wenn er zwei Assemblys hat (.dll + .exe).
Hat er nur eine (.exe) ist "internal" mit "public" gleichgestellt und somit komplett fürn Eimer.

Grüße

P.S. Will er eine Lib entwickeln, stellt sich dieses Problem natürlich erst gar nicht. Ich denke jedoch, dass er die 3 Klassen in seinem Projekt benutzen möchte?!

NoAir schrieb:

Hallo,

"internal" geht nur, wenn er zwei Assemblys hat (.dll + .exe).
Hat er nur eine (.exe) ist "internal" mit "public" gleichgestellt und somit komplett fürn Eimer.

Grüße

P.S. Will er eine Lib entwickeln, stellt sich dieses Problem natürlich erst gar nicht. Ich denke jedoch, dass er die 3 Klassen in seinem Projekt benutzen möchte?!

Wenn es sein Projekt ist und nur er daran arbeitet, hat er kein Problem damit die Klassen in eine eigene Assembly auszulagern, wenn er die Klassen für andere als Lib bereitstellen will, hat er auch "kein Problem" damit sie in eine eigene Assembly auszulagern...

Wo genau liegt das Problem? Von ihm selbst habe ich als Einwand nur gelesen, dass es eine Konsolenanwendung ist, was natürlich kein gültiger Einwand ist.

Ja sicher, aber er wollte anfangs auch nur wissen, ob es ein Pattern dazu gibt.

Das mit den Assemblys und deren Sichtbarkeit ist meiner Meinung nach nur ein Workaround und hat nichts mit einem Pattern im ursprünglichen Sinne zu tun

NoAir schrieb:

Ja sicher, aber er wollte anfangs auch nur wissen, ob es ein Pattern dazu gibt.

Das mit den Assemblys und deren Sichtbarkeit ist meiner Meinung nach nur ein Workaround und hat nichts mit einem Pattern im ursprünglichen Sinne zu tun

Also meinem Verständnis nach ist "internal" kein "Workaround", sondern genau für solche Fälle da...

Und wenn's schonmal da ist... sollte man es auch nutzen.

Firefighter

Hehe danke für eure große Anteilnahme, die Postings die ich gelesen habe, haben mir auf jedenfall sehr geholfen, vielen Dank für eure Meinungen.

Firefighter

Sagen wir es mal einfach ich will sowas wie in C++ mit friend auch in C# machen.Anscheint geht das aber nicht einfach, dachte mir das ich dafür nen Wrapper schreibe, ich werde es euch wissen lassen wenn ich weiter bin.

Firefighter schrieb:

Sagen wir es mal einfach ich will sowas wie in C++ mit friend auch in C# machen.Anscheint geht das aber nicht einfach, dachte mir das ich dafür nen Wrapper schreibe, ich werde es euch wissen lassen wenn ich weiter bin.

Hallo? Jemand zuhause? Genau dafür ist der Zugriffsmodifizierer "internal" gedacht, wobei die "friends" halt in einer Assembly zusammengefasst werden (dass es auch friend-assemblies gibt, lass ich mal aussen vor). Woran scheitert es denn nun?

Firefighter

Öhm da bin ich ehrlich gesagt, nicht der Meinung. Wenn ich in C++ mit friend arbeite, bezieht sich friend einschließlich auf die Klasse in welcher es angwendet wird, wenn ich internal anwende, bezieht es sich auf meine ganze Assembly und es wurde schon in vorherigen Posts korrekt erkkannt wie ich es machen möchte.

NoAir schrieb:
Hallo,

"internal" geht nur, wenn er zwei Assemblys hat (.dll + .exe).
Hat er nur eine (.exe) ist "internal" mit "public" gleichgestellt und somit komplett fürn Eimer.

Grüße

P.S. Will er eine Lib entwickeln, stellt sich dieses Problem natürlich erst gar nicht. Ich denke jedoch, dass er die 3 Klassen in seinem Projekt benutzen möchte?!

Und friend und internal zeigen in meinen Augen überhaupt nicht das Ergebnis was ich erwarte.Aber anscheint funktioniert es einfach nicht so Trotzdem danke für die Antworten.

hajb

jo.

Ich verstehe das so: Dummy soll seinen Zustand verbergen. Vermutlich eine gute Idee. Aber der Zustand ist nicht konstant, denn Actors (und ggf. andere) sollen ja den Zustand ändern können, nur eben nicht beliebig. Dann lass den Dummy das doch selbst machen! Dein Pattern heißt "Methode". Wenn nur bestimmte Dinge nicht gemacht werden dürfen (zb. negative Werte), dann kannst du auch eine Property nehmen und den Wert vor der Zuweisung prüfen.

class Dummy
{
	private int wichtigevariable;

	public Dumm()
	{
		//...
	}
	//readonly property wird man vielleicht auch mal brauchen
	public int WichtigeVariable { get { return wichtigevariable; } }

	public void TuWas()
	{
		//TODO: Add logic here 
		// e.g.:
 		++wichtigevariable;
	}
}
class Holder
{
	private readonly Dummy dummy;
	public Dummy{ get { return dummy; } }

	public Holder(Dummy dumm)
	{
		dummy=dumm;
		//...was mit dem Dummy
	}
}
class Acter
{
	private Dictionary<int,Holder> dummys;

	public Acter()
 	{
		//....
	}
	public void erhoehen(/*irgendwelche parameter*/)
	{
		foreach(Holder holder in dummys)
		{
			//TODO: Add more logic here
			holder.Dummy.TuWas();
			//TODO: And here
		}
	}
}

Grantopalen.

Firefighter

Hmm das wäre eine Möglichkeit.Danke dir für die ausführliche Antwort.

Ok, ich geb's auf. Evtl. einfach mal nach "c# internal friend" googeln, vielleicht fällt dann der Cent.

hajb

internal verbirgt nicht den Zustand, des Objektes sondern schränkt die Sichtbarkeit außerhalb der Assembly ein. Ich will zwei Klassen nicht in eine Assembly auslagern, nur weil ich erreichen will, dass sie miteinander kommunizieren können und andere mit ihnen nicht. also ist's hier bullshit.

Und das "es genau für diesen Fall da ist" verstehe überhaupt nicht. Was ist denn der Fall? [BUZZ]information hiding[\BUZZ]?

Grantopalen.

Firefighter

hajb schrieb:

internal verbirgt nicht den Zustand, des Objektes sondern schränkt die Sichtbarkeit außerhalb der Assembly ein. Ich will zwei Klassen nicht in eine Assembly auslagern, nur weil ich erreichen will, dass sie miteinander kommunizieren können und andere mit ihnen nicht. also ist's hier bullshit.

Und das "es genau für diesen Fall da ist" verstehe überhaupt nicht. Was ist denn der Fall? [BUZZ]information hiding[\BUZZ]?

Grantopalen.

Danke, genau darum gehts mir, ich will das selbe wie in C++ mit friend nur in C# erreichen, anscheint gibt es dafür kein passendes Pattern, muss ich mir mal selber was überlegen.