C #: Auslösen eines geerbten Ereignisses

Ich habe eine Basisklasse, die die folgenden Ereignisse enthält:

public event EventHandler Loading;
public event EventHandler Finished;

In einer Klasse, die von dieser Basisklasse erbt, versuche ich, das Ereignis auszulösen:

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

Ich erhalte folgende Fehlermeldung:

Das Ereignis 'BaseClass.Loading' kann nur auf der linken Seite von + = oder - = (BaseClass ') angezeigt werden.

Ich gehe davon aus, dass ich nicht wie andere geerbte Mitglieder auf diese Ereignisse zugreifen kann.

Was Sie tun müssen, ist Folgendes:

Erstellen Sie in Ihrer Basisklasse (in der Sie die Ereignisse deklariert haben) geschützte Methoden, mit denen die Ereignisse ausgelöst werden können:

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

(Beachten Sie, dass Sie diese Methoden wahrscheinlich ändern sollten, um zu überprüfen, ob Sie den Eventhandler aufrufen müssen oder nicht.)

In Klassen, die von dieser Basisklasse erben, können Sie dann einfach die Methoden OnFinished oder OnLoading aufrufen, um die Ereignisse auszulösen:

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

Sie können nur auf ein Ereignis in der deklarierenden Klasse zugreifen, da .NET hinter den Kulissen, in denen sich der Delegat tatsächlich befindet, private Instanzvariablen erstellt. Dies tun..

public event EventHandler MyPropertyChanged;

macht das tatsächlich;

private EventHandler myPropertyChangedDelegate;

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

und das tun ...

MyPropertyChanged(this, EventArgs.Empty);

ist eigentlich das ...

myPropertyChangedDelegate(this, EventArgs.Empty);

Sie können also (offensichtlich) nur innerhalb der deklarierenden Klasse auf die Instanzvariable des privaten Delegaten zugreifen.

Die Konvention sieht vor, so etwas in der deklarierenden Klasse bereitzustellen.

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

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

Sie können dann OnMyPropertyChanged(EventArgs.Empty)von einer beliebigen Stelle in dieser Klasse oder unterhalb der Vererbungshierarchie aufrufen, um das Ereignis aufzurufen.

Ich gehe davon aus, dass ich nicht wie andere geerbte Mitglieder auf diese Ereignisse zugreifen kann.

Genau. Es ist üblich, eine geschützte Funktion OnXyzoder RaiseXyzfür jedes Ereignis in der Basisklasse bereitzustellen , um das Auslösen aus geerbten Klassen zu ermöglichen. Beispielsweise:

public event EventHandler Loading;

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

In der geerbten Klasse aufgerufen:

OnLoading();

Sie können dies versuchen, es funktioniert für mich:

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

Nicht um einen alten Faden wiederzubeleben, aber falls jemand hinschaut, war das, was ich getan habe

protected EventHandler myPropertyChangedDelegate;

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

Auf diese Weise können Sie das Ereignis in einer abgeleiteten Klasse erben, sodass Sie es aufrufen können, ohne die Methode umbrechen zu müssen, während Sie die Syntax + = beibehalten. Ich denke, Sie könnten das immer noch mit den Verpackungsmethoden tun, wenn Sie dies tun würden

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