Was ist der beste Weg, um verkettete Ereignisse in C # zu implementieren

Ich habe das folgende Szenario. Der Client-Code hat nur Zugriff auf FooHandler, nicht direkt auf Foo-Instanzen.

public delegate void FooLoaded(object sender, EventArgs e);

class Foo {
    public event FooLoaded loaded;
    /* ... some code ... */
    public void Load() { load_asynchronously(); }
    public void callMeWhenLoadingIsDone() { loaded(this,EventArgs.Empty); }
}

class FooHandler {
    public event FooLoaded OneFooLoaded;

    /* ... some code ... */

    public void LoadAllFoos() { 
        foreach (Foo f in FooList) { 
            f.loaded += new FooLoaded(foo_loaded);
            f.Load(); 
        } 
    }

    void foo_loaded(object sender, EventArgs e) {
        OneFooLoaded(this, e);
    }

}

Dann würden die Clients das OneFooLoaded-Ereignis der FooHandler-Klasse verwenden, um Benachrichtigungen über das Laden von Foos abzurufen. Ist diese Event-Verkettung das Richtige? Gibt es Alternativen? Ich mag das nicht (es fühlt sich falsch an, ich kann nicht genau ausdrücken warum), aber wenn ich möchte, dass der Handler der Zugangspunkt ist, habe ich anscheinend nicht viele Alternativen.

Antworten auf die Frage(5)

Ihre Antwort auf die Frage