Generic Delegate zwischenspeichern

Fedaykin

Ich habe ein Generic Delegate

delegate T Foo<T>(T bar);

dieses möchte ich in einer Liste zwischenspeichern und bei bedarf mit einem T aufrufen

public void CallFoo<T>(T bar)
{
   myFooDelegate<T>(bar);
}

hab ich dazu irgendeine Chance? Oder ist das nicht möglich. Spätestens wenn ich mir eine Variable von meinen DelegateTyp in einer liste speichern möchte geht das schief weil er dort explizit den Typ von T erwartet.

Mach doch eine Delegate Collection Klasse

class DelegateCollection<T>
	{
		List<Foo<T>> _list = new List<Foo<T>>();

		public delegate T Foo<T>(T bar);

		public void Add(Foo<T> del) 
		{
			_list.Add(del);
		}
	}

Fedaykin

Dummerweise variiert das T innerhalb der Collection, eigentlich könnte ich sogar die T's stur als Object nehmen ich will nur ein Boxing verhindern weil vieles der Parameter eigentlich primitive sein dürften. Im schlimmsten fall muss ich mir wohl mehrere Collections machen und dann per Typeof schauen in welcher ein konkretes Delegate für einen bestimmten Type steckt. irgendwie finde ich das etwas umständlich.

Was hast du den genau vor?

Fedaykin

Get und Set methode für einzelne Klassenvariablen zu machen. Das ganze detailiert zu erklären ist etwas umständlich. Sagen wir mal so, ich baue ein Interface welches mir Zugriff auf noch unbekannte Objekte gewährt.

IBase
{
   string[] Properties();
   T GetProperty<T> Get(string name);
   void SetProperty<T> Set(string name);
}

ImplOfBase
{
  private int MyInt;
  List<string> Properties()
  {
     return new string[]{"MyInt"};
  }
  T GetProperty<T> Get(string name)
  {
     if ( name == "MyInt")
       return (T)MyInt;
     else throw new InvalidPropertyException
  }

  void SetProperty<T> Set(string name)
  {
     ...//Set for the properties
  }
}

Prinzipell sollen diese Klassen dann noch PropertieChangeSupport und ähnliches anbieten. Das ganze brauch ich daher, weil ich noch nicht weiss wie die eigentlichen Daten die dort reinhkommen später mal aussehen werden. Um das ganze noch zu vereinfachen baue ich eine Abstrakte Basisklasse was das meiste schon allein macht (Get/Set) dazu verwende ich ein Propertiemap. Dort sind gespeichert der Name und Get und Set delegates für die einzelnen Variablen. Ausserdem existiert eine Methode welche diese Map per Reflection setzt. (Reflection wird bei uns nicht gerne gesehen daher biete ich es an aber niemand muss die funktion verwenden man kann die map auch von hand füllen). Die Get und Set Methoden der Abstrakten Klasse führen dann nur noch Delegates aus.
Beispiel:

delegate void Set(Object o);
delegate Object Get();

public class Impl2
{
   int myint;
   public Impl2()
   {
      Set setter = delegate(Object o)
      {
         myint = (int)o;
      }
      Get getter = delegate()
      {
         return myint;
      }
      AddAccessor("myint",setter,getter);
   }
}

Das PRoblem ist halt nun das ich das aktuell alles über Object mache. Das heißt die Primitven werte werden geboxt bzw unboxt was bei vielen aufrufen Speicher und Zeit frisst. Das ganze hätte ich gerne über Generics aufgelöst. Aber das ist scheinbar etwas schwieriger.

Rhombicosidodecahedron

Fedaykin schrieb:

Dein Boxing verhindern weil vieles der Parameter eigentlich primitive sein dürften.

Boxing ist nur bei Primitiven oder Structs. Delegates sind AFAIK aber Objects (egal ob mit oder ohne Primitvtypparameter- da es ja entscheidend ist ob die Delegates an sich ein RefTRyp ist oder nicht) und es sind dementsprehchend "nur" Typkonvertierungen.