C# - Erweiterung Methode auf Typ Mit Generic Type Arguments

Ich bin auf der Suche nach wegen zur Verbesserung der Kohärenz, der Vereinfachung und der Lesbarkeit von code in der Anwendung an der ich arbeite. Der Start-code sah so etwas wie dieses:

context.GetGraphType<Bar>().Subscribe<Fizz>(
     (instance, evt) => evt.Execute((Bar)instance.Instance)
);

Gibt es eine Reihe von nahezu identische code-Zeilen wie die oben genannten. Ich wollte umschreiben, dass es so Aussehen:

typeof(Bar).SubscribeTo<Fizz>(context);

Für eine Sache, das würde mir erlauben, zu nutzen, zu formalisieren, was bereits zu einem informellen übereinkommen. Auch habe ich gehofft, es würde nun etwas gelesen wie "bar abonniert die fizz-event auf den gegebenen Kontext", sondern als "Kontext bekommt die bar-Typ und abonniert fizz und dann tut einige Sachen." Ich denke, dass der flow ist besser, und die Mitarbeiter, die ich gefragt vereinbart.

Ich begann zu implementieren dies als eine Erweiterung-Methode. Um zu erreichen die oben, wollte ich machen Verwendung von eine abstrakte generische Basisklasse für die Veranstaltung geben, so Fizz wäre Event<T>. Dies würde bedeuten, dass der generische Typ-argument für die Erweiterung Methode müsste eingeschränkt werden, der Art, dass die extension-Methode aufgerufen wird. Also für das obige Beispiel Fizz müsste der Typ Event<Bar>.

Ist das möglich? Ich ging mit einer alternativen Lösung in der Zwischenzeit, aber ich bin immer noch neugierig, ob es erreicht werden kann. Andere Vorschläge sind willkommen, wie gut.

Dank!

Edit #1: Nur um klar zu sein, ich weiß, dass ich könnte eine zusätzliche Typ-parameter, aber ich bin auf der Suche nach Möglichkeiten, Sie zu vermeiden, wenn möglich.

Edit #2:
Ich denke, ich werde gehen, mit einer leichten variation der akzeptierten Antwort, denn es entspricht nicht 100% mit meinem Szenario. Die Quintessenz ist, dass eine generische statische Klasse kann stattdessen verwendet werden, der eine Erweiterung Methode des Typs zu erreichen, ist mein Ziel. Dank dss539!

Update-code (es kann sein, Tippfehler, seit ich das hier mache, on-the-fly):

public class Bar { }

public class Event<TSubscriber>
{
    public abstract void Execute(TSubscriber source);
}

public class Fizz : Event<Bar>
{
    public override void Execute(Bar bar)
    {
        //respond to event
    }
}

public class Context { }

public static class ForType<TSubscriber>
{
    public static void SubscribeTo<TEvent>(Context context)
        where TEvent : Event<TSubscriber>
    {
        context.GetType<TSubscriber>().Subscribe<TEvent>(
            (evt, args) => evt.Execute((TSubscriber)args.Source));
    }
}

public static void Run()
{
    ForType<Bar>.SubscribeTo<Fizz>(context);
}

Ich verstehe nicht ganz deine Frage. Was macht Ihre vorhandene Signatur der Methode Aussehen? Subscribe<T>(this Type type, Action<T, Fizz>)? Wenn Sie zeigen, was Sie haben(oder gleichwertig), die möglicherweise helfen, zu erklären.
Ich glaube, ich hatte ein ähnliches design-Problem eine Weile zurück. Viel Glück 🙂
Es wäre mehr wie Abonnieren<T>(dieser Typ, Context ctx). Das problem ist, dass es keine Möglichkeit gibt (die ich kenne) zu beschränken, dass T vom Typ Event<geben Sie "type" - parameter>.
es klingt wie Sie versuchen, access-Laufzeit-Informationen, die beim kompilieren/Bearbeiten Zeit. Der Typ-parameter muss kein Wert erst zur Laufzeit.
Das ist, was ich dachte, wollte nur die Bestätigung und eine gute Erklärung, das war mehr als eine Ahnung oder Vermutung. Und vielen Dank für eine hervorragende Antwort! Akzeptiert...
danke für den Hinweis

InformationsquelleAutor Bryan Matthews | 2010-06-25

.net c#extension-methods generic-programming generics

Dies ist nicht genau wie Sie gefragt, aber vielleicht wird es ausreichen.

internal class Program
{
    static void Main(string[] args)
    {
        var fizzHandler = new Fizz();
        var context = new Context();
        Handle<Bar>.With(fizzHandler, context);
    }
}
public class Bar { }
public class Event<T> { }
public class Fizz : Event<Bar> { }
public class Context { };
public static class Handle<T>
{
    public static void With(Event<T> e, Context c)
    {
        //do your stuff
    }
}

Das ist genau das, was ich suchte. Es erlaubt mir, mich zu erreichen, mein ursprüngliches Ziel, die Lesbarkeit, ohne Umgehung der compiler. Danke!
froh, dass ich helfen konnte 🙂

InformationsquelleAutor dss539

4

Warum nicht etwas ein bisschen mehr idomatic, wo man generische constraints, die Regeln durchzusetzen:
```
 public static class SubscriptionManager
 {
     public static void SubsribeTo<TSub,TEvent>( Context context )
         where TEvent : Event<TSub>
     {
        ///you code...
     }
 }
```
Die Aufrufe Aussehen würde:
```
 SubscriptionManager.SubsribeTo<Bar,Fizz>( context );
```
Die Einschränkung where TEvent : Event<TSub> sichert die Beziehung zwischen dem Ereignis und Abonnement-Typ, den Sie wünschen. Es ist auch vorzuziehen, die in meinem Buch eine extension-Methode auf die Klasse Type - weil, die neigt zu Unordnung intellisense. Type ist in vielen Situationen, und mit fadenscheinigen Methoden in Intellisense angezeigt, die auf alle Instanzen von Type eher verwirrend. Es ist auch nicht offensichtlich für den Verbraucher der Bibliothek, die Sie auf diese Weise "abonnieren" - es sei denn, Sie haben tatsächlich gesehen, wie ein code-Beispiel für Sie.
- Vielen Dank für deine Antwort! Ich merke, dass diese Einschränkung können Sie erzwingen auf diese Weise (siehe oben edit). Ihr Vorschlag ist in der Nähe eine, die ich in Betracht gezogen, aber bevorzugt die extension-Methode. Ich verstehe die Abneigung gegen die Verwendung von extension-Methoden einer Klasse wie der Typ, aber die Methode ist lokalisiert, um eine einzelne Klasse, die Griffe der Abonnements. Auch ist es nicht eine Bibliothek, Methode, der wäre konsumiert werden, von anderen.
InformationsquelleAutor LBushkin
0

Kann man wahrscheinlich schließen, erweitern System.Type (haben typeof(T).) und hinzufügen (Erweiterung) - Methode, um Rahmen, die verwandelt .NET-Typ auf Ihrer internen Darstellung (gleiche zurückgegeben durch GetGraphType).
```
static class Ext {

    public static TypeofTypeofBar GetGraphTypeFromDotNetType(this Context ctx, Type t) {
       return __something(t);
    }

    public static void SubscribeTo<F, E>(this Type type, Context ctx, E e)
        where E: Event<T> {
        context.GetGraphTypeFromDotNetType(type).Subscribe<F>(a);
    }

}
```
...
```
typeof(Bar).SubscribeTo(context, action);
```
- Hey Mau, passiert einfach so, die Methode, die Sie beschrieben haben, bereits vorhanden ist. Ich bin ein bisschen verwirrt über die Typ-Parameter in deinem Beispiel. Meinst du "wo E : Event<F>"? Wenn das der Fall war würde ich nicht übergeben zu müssen, ein "event" - argument, der Typ würde ausreichen (in der Tat, ich würde nicht in der Lage sein, um eine event-Instanz). Es scheint jedoch, wie der Typ des Abonnenten würden noch versorgt werden müssen als type-parameter. So würden Sie im Grunde am Ende mit "typeof(Bar).SubscribeTo<Bar, Fizz>(ctx)", das ist noch eine andere Variante, die ich bin nicht begeistert. Danke für den Vorschlag aber!
InformationsquelleAutor Mau

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.