C #: generar un evento heredado

Tengo una clase base que contiene los siguientes eventos:

public event EventHandler Loading;
public event EventHandler Finished;

En una clase que hereda de esta clase base, trato de generar el evento:

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

Recibo el siguiente error:

El evento 'BaseClass.Loading' solo puede aparecer en el lado izquierdo de + = o - = (BaseClass ')

¿Asumo que no puedo acceder a estos eventos de la misma manera que otros miembros heredados?

Lo que tienes que hacer es esto:

En su clase base (donde ha declarado los eventos), cree métodos protegidos que puedan usarse para generar los eventos:

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

(Tenga en cuenta que probablemente debería cambiar esos métodos para verificar si tiene que invocar el controlador de eventos o no).

Luego, en las clases que heredan de esta clase base, puede llamar a los métodos OnFinished o OnLoading para generar los eventos:

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

Solo puede acceder a un evento en la clase de declaración, ya que .NET crea variables de instancia privadas detrás de escena que realmente contienen al delegado. Haciendo esto..

public event EventHandler MyPropertyChanged;

en realidad está haciendo esto;

private EventHandler myPropertyChangedDelegate;

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

y haciendo esto ...

MyPropertyChanged(this, EventArgs.Empty);

es en realidad esto ...

myPropertyChangedDelegate(this, EventArgs.Empty);

Por lo tanto, (obviamente) solo puede acceder a la variable de instancia de delegado privado desde la clase de declaración.

La convención es proporcionar algo como esto en la clase de declaración.

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

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

Luego puede llamar OnMyPropertyChanged(EventArgs.Empty)desde cualquier lugar de esa clase o debajo de la jerarquía de herencia para invocar el evento.

¿Asumo que no puedo acceder a estos eventos de la misma manera que otros miembros heredados?

Precisamente. Es habitual proporcionar una función protegida OnXyzo RaiseXyzpara cada evento en la clase base para permitir el aumento de clases heredadas. Por ejemplo:

public event EventHandler Loading;

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

Llamado en la clase heredada:

OnLoading();

Puedes probar de esta manera, funciona para mí:

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

no para resucitar un hilo viejo pero en caso de que alguien esté mirando, lo que hice fue

protected EventHandler myPropertyChangedDelegate;

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

Esto le permite heredar el evento en una clase derivada para que pueda invocarlo sin necesidad de ajustar el método manteniendo la sintaxis + =. Supongo que aún podrías hacerlo con los métodos de envoltura si lo hicieras

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