Eu tenho o seguinte cenário. O código do cliente só tem acesso ao FooHandler, não diretamente às instâncias do Foo.

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);
    }

}

Em seguida, os clientes usariam o evento OneFooLoaded da classe FooHandler para receber notificações de carregamento de foos. Este 'evento de encadeamento' é a coisa certa a fazer? Existem alternativas? Eu não gosto disso (parece errado, eu não posso expressar precisamente por quê), mas se eu quero que o manipulador seja o ponto de acesso, não pareço ter muitas alternativas.