C #: generazione di un evento ereditato

Ho una classe base che contiene i seguenti eventi:

public event EventHandler Loading;
public event EventHandler Finished;

In una classe che eredita da questa classe di base, provo a sollevare l'evento:

this.Loading(this, new EventHandler()); // All we care about is which object is loading.

Ricevo il seguente errore:

L'evento 'BaseClass.Loading' può apparire solo sul lato sinistro di + = o - = (BaseClass ')

Suppongo di non poter accedere a questi eventi allo stesso modo degli altri membri ereditati?

Quello che devi fare è questo:

Nella tua classe di base (dove hai dichiarato gli eventi), crea metodi protetti che possono essere utilizzati per aumentare gli eventi:

public class MyClass
{
   public event EventHandler Loading;
   public event EventHandler Finished;

   protected virtual void OnLoading(EventArgs e)
   {
       EventHandler handler = Loading;
       if( handler != null )
       {
           handler(this, e);
       }
   }

   protected virtual void OnFinished(EventArgs e)
   {
       EventHandler handler = Finished;
       if( handler != null )
       {
           handler(this, e);
       }
   }
}

(Nota che probabilmente dovresti cambiare questi metodi, per verificare se devi invocare il gestore dell'evento o meno).

Quindi, nelle classi che ereditano da questa classe di base, puoi semplicemente chiamare i metodi OnFinished o OnLoading per generare gli eventi:

public AnotherClass : MyClass
{
    public void DoSomeStuff()
    {
        ...
        OnLoading(EventArgs.Empty);
        ...
        OnFinished(EventArgs.Empty);
    }
}

È possibile accedere a un evento solo nella classe dichiarante, poiché .NET crea variabili di istanza private dietro le quinte che detengono effettivamente il delegato. Facendo questo..

public event EventHandler MyPropertyChanged;

lo sta effettivamente facendo;

private EventHandler myPropertyChangedDelegate;

public event EventHandler MyPropertyChanged
{
    add { myPropertyChangedDelegate += value; }
    remove { myPropertyChangedDelegate -= value; }
}

e facendo questo ...

MyPropertyChanged(this, EventArgs.Empty);

è in realtà questo ...

myPropertyChangedDelegate(this, EventArgs.Empty);

Quindi puoi (ovviamente) accedere alla variabile di istanza del delegato privato solo all'interno della classe dichiarante.

La convenzione prevede di fornire qualcosa del genere nella classe dichiarante.

protected virtual void OnMyPropertyChanged(EventArgs e)
{
    EventHandler invoker = MyPropertyChanged;

    if(invoker != null) invoker(this, e);
}

È quindi possibile chiamare OnMyPropertyChanged(EventArgs.Empty)da qualsiasi parte di quella classe o al di sotto dell'eredità gerarchica per invocare l'evento.

Suppongo di non poter accedere a questi eventi allo stesso modo degli altri membri ereditati?

Precisamente. È consuetudine fornire una funzione protetta OnXyzo RaiseXyzper ogni evento nella classe base per consentire il rilancio da classi ereditate. Per esempio:

public event EventHandler Loading;

protected virtual void OnLoading() {
    EventHandler handler = Loading;
    if (handler != null)
        handler(this, EventArgs.Empty);
}

Chiamato nella classe ereditata:

OnLoading();

Puoi provare in questo modo, funziona per me:

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

public class B
{
    public virtual event MyEventHaldler MyEvent;
    protected override void OnChanged(EventArgs e)
    {
        if (MyEvent != null)
            MyEvent(this, e);
    }
}

public class D : B
{
    public override event MyEventHaldler MyEvent;
    protected override void OnChanged(EventArgs e)
    {
        if (MyEvent != null)
            MyEvent(this, e);
    }
}

non resuscitare un vecchio filo, ma nel caso qualcuno stia guardando, quello che ho fatto è stato

protected EventHandler myPropertyChangedDelegate;

public event EventHandler MyPropertyChanged
{
    add { myPropertyChangedDelegate += value; }
    remove { myPropertyChangedDelegate -= value; }
}

Ciò consente di ereditare l'evento in una classe derivata in modo da poterlo richiamare senza richiedere il wrapping del metodo mantenendo la sintassi + =. Immagino che potresti farlo con i metodi di avvolgimento, se lo facessi

public event EventHandler MyPropertyChanged
{
   add { AddDelegate(value); }
   remove { RemoveDelegate(value); }
}