Typen / Klassen als Parameter verwenden

[Khabarakh]

Nicht so kompliziert denken und einfach Instanzmethoden daraus machen ? Ich sehe da keinen Nachteil - und wie gesagt können sich dadurch sogar ganz andere Möglichkeiten eröffnen :

Code:

   class Dispatcher
   {
      [ImportMany]
      IEnumerable<ServerEvent> EventHandlers { get; set; }

      public Dispatcher()
      {
         // Here be MEF magic...
         var catalog = new DirectoryCatalog(@".\");
         var container = new CompositionContainer(catalog);
         container.Composeparts(this);
      }

      void Receive()
      {
         ServerEvent handler = EventHandlers.First(h => h.Command == command);
         handler.Handle();
      }
   }

   public abstract class ServerEvent
   {
      public virtual string Command { get { return ""; } }
      public void Handle();
   }

   [Export(ServerEvent)]
   class IAmATeapotServerEvent : ServerEvent { ... }

Wirf eine weitere Assembly mit einer ServerEvent-Ableitung in den bin-Ordner und MEF wird sie ohne weiteres Zutun ebenfalls dem Dispatcher zuordnen. Und jetzt sag mir, dass das mit statischen virtuellen Methoden eleganter lösbar sei .

[Meflin]

Das klingt natürlich wirklich nett. Einen Haken hat das ganze allerdings: das gibts alles erst ab .Net 4 oder? Ich bin aber an 3.5 gebunden, durch andere Libraries...

Zitat von Khabarakh:

Nicht so kompliziert denken und einfach Instanzmethoden daraus machen ? Ich sehe da keinen Nachteil - und wie gesagt können sich dadurch sogar ganz andere Möglichkeiten eröffnen

Ist ja nicht so dass ich was gegen Instanzen hätte Nur bei meinem Ansatz wären sie einfach überflüssig gewesen...

[Phoenix]

Du kannst doch einfach per reflection hergehen, die statischen Methode ermitteln und aufrufen.
Um die Typen zu finden die diese Methode implementieren kannst du im Prinzip hergehen und mittels linq abfragen, welche typen eine statische Methode dieses namens haben. Das ist aber nicht gerade Performant, weil die Abfrage alle typen nach der Methode abfragt.

[Meflin]

Zitat von Phoenix:

Du kannst doch einfach per reflection hergehen, die statischen Methode ermitteln und aufrufen.

Naja gehen täte das sicherlich. Aber hübsch finde ich das nun auch nicht gerade.

Mal gucken ob ich nicht doch auf 4 umsteigen kann...

[Phoenix]

Hast Du Einfluss auf die Klassen die Du da verwendest? Kannst Du die z.B. mit einem Custom Attribut versehen oder von einem bestimmten Interface ableiten (ich weiss, bei statischen Methoden ist das eher Sinnlos, aber z.B. INamingContainer ist auch nur ein flagging interface das keine Methoden oder Properties vorgibt).

Das macht dann das Ermitteln der entsprechenden Typen ziemlich einfach.

Ps: Ich erwähne jetzt nur am Rande das Prism virtuelle statische Methoden schon länger unterstützt: http://prismwiki.embarcadero.com/en/Class_References ...

[Meflin]

Zitat von Phoenix:

Hast Du Einfluss auf die Klassen die Du da verwendest? Kannst Du die z.B. mit einem Custom Attribut versehen oder von einem bestimmten Interface ableiten (ich weiss, bei statischen Methoden ist das eher Sinnlos, aber z.B. INamingContainer ist auch nur ein flagging interface das keine Methoden oder Properties vorgibt).

Die Klassen stammen allesamt von mir - ich kann da also machen was ich will

Wie sich das nun auswirkt, verstehe ich allerdings nicht, denn von Reflection in C# habe ich ehrlichgesagt null Ahnung

[Phoenix]

Du kannst sowas machen:

Code:

var results = from type in someAssembly.GetTypes()
              where typeof(IFoo).IsAssignableFrom(type)
              select type;

Du hast in results dann eine Liste aller Typen, die Dein Flagging interface haben.
Der Aufruf sieht dann in etwa so aus:

Code:

var t := results.First();
foreach (MethodInfo mi in t.GetMethods(BindingFlags.Static |
BindingFlags.Public))
{
  Console.WriteLine("method {0}", mi.Name);
  mi.Invoke(null, null); // parameter entsprechend setzen.
}

[Khabarakh]

Zitat von Meflin:

Das klingt natürlich wirklich nett. Einen Haken hat das ganze allerdings: das gibts alles erst ab .Net 4 oder?

Integriert ja, ansonsten... . Wenn du darin Overkill siehst, kann ich dir das aber schlecht verübeln, also würde ich in Anlehnung an Phoenix' Code den MEF-Composition-Teil durch

Code:

EventHandlers = Assembly.GetEntryAssembly().GetTypes().Where(t => t.IsSubclassOf(typeof(ServerEvent))).ToList();

ersetzen.

Zitat von Meflin:

Ich bin aber an 3.5 gebunden, durch andere Libraries...

Hm? Wenn du einen Breaking Change in 4.0 treffen solltest, gebe ich dir einen aus .

Zitat von Meflin:

Ist ja nicht so dass ich was gegen Instanzen hätte Nur bei meinem Ansatz wären sie einfach überflüssig gewesen...

Und Herr Hejlsberg dachte wahrscheinlich umgekehrt, dass ein Feature überflüssig ist, das sich (zumindest in Fällen wie diesem) ohne wirklichen Verlust auch auf einfacherem Weg realisieren lässt. Wie Eric Lippert es einmal sagte: Jedes Sprachfeature beginnt bei -500...
Und ohne dir nahe treten zu wollen, oder überhaupt zu wissen, wie tief du schon in der CLR drinsteckst, ist es imo ein beeinträchtigender Fehler von Umsteigern, in einer managed Sprache Instanzierungen zählen zu wollen. Sagt mir jedenfalls meine eigene Erfahrung - man muss loslassen können, um zu genießen .

@Sebastian: Uh, jetzt musst du mir aber dringend erklären, wo du nun noch einen Vorteil von statischen Methoden + Reflection siehst.

[Meflin]

Zitat von Khabarakh:

Und ohne dir nahe treten zu wollen, oder überhaupt zu wissen, wie tief du schon in der CLR drinsteckst...

Nur um mit einem kurzen Einwurf diese Frage zu beantworten: garnicht

[Meflin]

Zitat von Khabarakh:

Code:

   class Dispatcher
   {
      [ImportMany]
      IEnumerable<ServerEvent> EventHandlers { get; set; }

      public Dispatcher()
      {
         // Here be MEF magic...
         var catalog = new DirectoryCatalog(@".\");
         var container = new CompositionContainer(catalog);
         container.Composeparts(this);
      }

      void Receive()
      {
         ServerEvent handler = EventHandlers.First(h => h.Command == command);
         handler.Handle();
      }
   }

   public abstract class ServerEvent
   {
      public virtual string Command { get { return ""; } }
      public void Handle();
   }

   [Export(ServerEvent)]
   class IAmATeapotServerEvent : ServerEvent { ... }

Also beim Versuch der Umsetzung dieser durchaus reizvollen Lösungsidee bin ich jetzt leider doch noch auf Probleme gestoßen.

Code:

[Export(ServerEvent)]

wird bei mir nicht zugelassen mit Fehler Verwendung eines Typen wie Variable etc... Ich hab ees dann hauptsächlich so versucht:

Code:

[Export(typeof(ServerEvent))]
[ImportMany(typeof(ServerEvent))]

da wird dann allerdings außer der abstrakten Basisklasse garnichts importiert. So wurde das ganze allerdings in den Beispielcodes die ich gefunden habe angewendet

Ich bitte um Erleuchtung