Statische Methoden und ableitungen.

Fedaykin

Angenommen ich habe eine Klasse Base

public MyDelegate(Base o1, object irgendwas);
public class Base
{
   protected static Dictionary<string,MyDelegate> dict;
   .
   .
   .
   public void Do(string s, object value)
   {
      dict[s](this,value);
   } 
}

Von dieser Klasse erben 2 weitere D1 und D2

public MyDelegate(Base o1, object irgendwas);
public class D1: Base
{
   int IntValue;
}

public class D2: Base
{
   string StringValue;
}

Gibt es für D1 oder D2 irgend ne möglichkeit das dict so zu befüllen das es für D1 und D2 eindeutig ist. Aber z.b folgendes funktioniert?

Base d2 = new D2();
d2.Do("StringValue","newString");

Kurzum, ich müsste für jede Ableitung von Base, das dict mit Delegates befüllen welche das ändern der einzelnen Member erlauben. (Dabei wird halt viel gecastet). Es ist sozusagen sowas wie Reflection bei dem ich die Meta informationen für jede Klasse selber erzeugen muss. Aktuell hab ich das ganze nur ohne static dictionary. D.H. jedes Objekt hat sein eigenes dict. Das ist aber Speicherverschwendung da im Endeffekt viele D2 Objekte existieren mit vielen lokalen Dictionarys die aber alle die selben String->Delegate zuordnungen haben. Genau das möchte ich nun wegmachen. Welche möglichkeiten hab ich da?

Dravere

Wie wäre es, wenn du einfach eine Typ-Klasse erstellst. Jedes Objekt der gleichen Klasse, hat dann eine Referenz auf das gleiche Typ-Klassen-Objekt. Grundsätzlich ähnlich wie es aktuell direkt von .Net implementiert ist: GetType() .
Wobei ich hier allerdings das grösste Problem bei den Delegates sehe. Man kann nicht wie in C++ einen Zeiger auf eine Methode speichern und diese Methode dann auf unterschiedlichen Objekten aufrufen. Das müsstest du dann irgendwie anders lösen.

Grüssli

Fedaykin

Interessanterweise bin ich auf fast genau den gleichen Ansatz gekommen und bin dabei den zu Implementieren.

Aber wo liegt genau das problem mit den Delegates? Ich speicher prinzipiell Zeiger auf Statische Methoden. Diese werden dann halt beim Aufruf von Do über eine Klasse mit this aufgerufen. Das Delegate kriegt also die Referenz auf das Objekt im ersten Parameter mitgeliefert.

Besten Dank dennoch.

Dravere

Fedaykin schrieb:

Aber wo liegt genau das problem mit den Delegates? Ich speicher prinzipiell Zeiger auf Statische Methoden. Diese werden dann halt beim Aufruf von Do über eine Klasse mit this aufgerufen. Das Delegate kriegt also die Referenz auf das Objekt im ersten Parameter mitgeliefert.

Achso, du speicherst statische Methoden und übergibst die Base-Referenz. Irgendwie ganz übersehen/überlesen.

Darf ich fragen, wozu du dies eigentlich benötigst?

Grüssli

Fedaykin

Um eben Reflection zu vermeiden. Wir haben die Auflagen möglichst wenig Reflection ein zu setzen. Ich soll aber anbieten, möglichst dynamisch, GUI's mit den Daten meine Klasse zu Füttern und zu befüllen. (Damit sind nicht reine C# GUI's gemeint sondern auch eigene Steuerelemente und dergleichen).
Kurz Gesagt: Ich kenne den allgemeinen Aufbau meine Objekte nicht, soll aber die möglichkeit haben in eigenen Grafikkomponenten daten aus diesen Objekten darzustellen.

Mein erste Gedanke ging in die Richtung das ich mit Reflection arbeite. Und INotificationSupport Implementiere (Damit ich die GUI bzw alle Elemente die DAten aus dem Objektmodell darstellen updaten kann).
Da Reflection "Langsam" ist, bastle ich mir halt eine Objektbeschreibung drumerhum die ohne Reflection auskommt aber prinzipiell ähnliches ermöglicht (Dafür eben nicht so leistungsstark) Obwohl das viele Boxing, Unboxing wohl auch nicht das schnellste ist.

Es läuft nun halt darauf hinauf das ich eine art PropertyBinding nachbaue . Ggf gibts dafür schon einfachere Sachen?

Das könnte so klappen:

public MyDelegate(Base o1, object irgendwas);
public class Base
{
   protected static Dictonary<Type, Dictionary<string,MyDelegate>> dict;

   public void Do(string s, object value)
   {
      dict[GetType()][s](this,value);
   }
} 

public MyDelegate(Base o1, object irgendwas);
public class D1: Base
{
   static D1
   { 
      Type myType =typeof(D1);
      dict.Add(),new Dictionary<string,MyDelegate>();
      dict[myType].Add("IntValue",new MyDelegate(..));
      ...
   }

   int IntValue;
}

public class D2: Base
{
   static D2
   { 
      Type myType =typeof(D2);
      dict.Add(),new Dictionary<string,MyDelegate>();
      dict[myType].Add("StringValue",new MyDelegate(..));
      ...
   }
   string StringValue;
}

Ich habe () bei dem Konstruktoren vergessen.

Hier noch mal ohne Fehler:

public MyDelegate(Base o1, object irgendwas);
public class Base
{
   protected static Dictionary<Type, Dictionary<string,MyDelegate>> dict;

   public void Do(string s, object value)
   {
      dict[GetType()][s](this,value);
   }
}

public MyDelegate(Base o1, object irgendwas);
public class D1: Base
{
   static D1()
   {
      Type myType =typeof(D1);
      dict.Add(myType,new Dictionary<string,MyDelegate>();
      dict[myType].Add("IntValue",new MyDelegate(..));
      ...
   }

   int IntValue;
}

public class D2: Base
{
   static D2()
   {
      Type myType =typeof(D2);
      dict.Add(myType,new Dictionary<string,MyDelegate>();
      dict[myType].Add("StringValue",new MyDelegate(..));
      ...
   }
   string StringValue;
}