C #: Возбуждение унаследованного события

Question

У меня есть базовый класс, который содержит следующие события:

public event EventHandler Loading;
public event EventHandler Finished;

В классе, который наследуется от этого базового класса, я пытаюсь вызвать событие:

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

Я получаю следующую ошибку:

Событие 'BaseClass.Loading' может появляться только в левой части + = или - = (BaseClass ')

Я предполагаю, что не могу получить доступ к этим событиям так же, как другие унаследованные члены?

Answer 1

Что вам нужно сделать, это:

В вашем базовом классе (где вы объявили события) создайте защищенные методы, которые можно использовать для вызова событий:

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

(Обратите внимание, что вам, вероятно, следует изменить эти методы, чтобы проверить, нужно ли вызывать обработчик событий или нет).

Затем в классах, которые наследуются от этого базового класса, вы можете просто вызвать методы OnFinished или OnLoading для вызова событий:

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

Answer 2

Вы можете получить доступ только к событию в объявленном классе, поскольку .NET создает частные переменные экземпляра за кулисами, которые фактически содержат делегат. Делаем это ..

public event EventHandler MyPropertyChanged;

на самом деле делает это;

private EventHandler myPropertyChangedDelegate;

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

и делает это ...

MyPropertyChanged(this, EventArgs.Empty);

на самом деле это ...

myPropertyChangedDelegate(this, EventArgs.Empty);

Таким образом, вы можете (очевидно) получить доступ только к закрытой переменной экземпляра делегата из объявленного класса.

Соглашение состоит в том, чтобы обеспечить что-то подобное в объявлении класса ..

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

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

Затем можно вызвать OnMyPropertyChanged(EventArgs.Empty) из любого места в этом классе или ниже иерархии наследования, чтобы вызвать событие.

Answer 3

Я предполагаю, что не могу получить доступ к этим событиям так же, как другие унаследованные члены?

Точно. Обычно для каждого события в базовом классе предусмотрена защищенная функция OnXyz или RaiseXyz, позволяющая вызывать унаследованные классы. Например:

public event EventHandler Loading;

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

Вызывается в унаследованном классе:

OnLoading();

Answer 4

не для того, чтобы воскресить старую ветку, но в случае, если кто-то ищет, я сделал

protected EventHandler myPropertyChangedDelegate;

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

Это позволяет вам наследовать событие в производном классе, чтобы вы могли вызывать его без необходимости переноса метода, сохраняя синтаксис + =. Я думаю, вы могли бы сделать это с помощью методов обтекания, если бы вы сделали

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

Answer 5

Можете попробовать вот так, у меня работает:

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