son - C#: levantando un evento heredado

qué es un evento c#

Question

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 plantear 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 al igual que a otros miembros heredados?

Answer 1

¿Asumo que no puedo acceder a estos eventos al igual que a otros miembros heredados?

Precisamente. Es costumbre proporcionar una función protegida OnXyz o RaiseXyz para cada evento en la clase base para habilitar el aumento desde las 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();

Answer 2

Lo que tienes que hacer es esto:

En su clase base (donde ha declarado los eventos), cree métodos protegidos que se puedan usar 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 deba cambiar esos métodos, para comprobar si debe invocar el manejador de eventos o no).

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

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

Answer 3

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

Answer 4

Solo puede acceder a un evento en la clase de declaración, ya que .NET crea variables de instancia privadas detrás de las escenas que realmente contienen el 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);

Entonces, puede (obviamente) acceder solo a la variable de instancia de delegado privada desde dentro de la clase declarante.

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

protected virtual void OnMyPropertyChanged(EventArgs e)
{
EventHandler invoker = MyPropertyChanged;
if(invoker != null) invoker(this, e);
}

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