C #: Élever un événement hérité

J’ai une classe de base qui contient les événements suivants:

public event EventHandler Loading; public event EventHandler Finished; 

Dans une classe qui hérite de cette classe de base, j’essaie de déclencher l’événement:

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

Je reçois l’erreur suivante:

L’événement ‘BaseClass.Loading’ ne peut apparaître que sur le côté gauche de + = ou – = (BaseClass ‘)

Je suppose que je ne peux pas accéder à ces événements de la même manière que les autres membres hérités?

Ce que vous devez faire, c’est ceci:

Dans votre classe de base (où vous avez déclaré les événements), créez des méthodes protégées qui peuvent être utilisées pour déclencher les événements:

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

(Notez que vous devriez probablement changer ces méthodes, afin de vérifier si vous devez ou non appeler le gestionnaire d’événements).

Ensuite, dans les classes qui héritent de cette classe de base, vous pouvez simplement appeler les méthodes OnFinished ou OnLoading pour déclencher les événements:

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

Vous ne pouvez accéder à un événement que dans la classe déclarante, car .NET crée des variables d’instance privées en arrière-plan qui contiennent réellement le délégué. Ce faisant..

 public event EventHandler MyPropertyChanged; 

est en train de le faire;

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

et en faisant ça …

 MyPropertyChanged(this, EventArgs.Empty); 

c’est en fait ça …

 myPropertyChangedDelegate(this, EventArgs.Empty); 

Vous pouvez donc (évidemment) accéder uniquement à la variable d’instance de délégué privé depuis la classe déclarante.

La convention est de fournir quelque chose comme ça dans la classe déclarante.

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

Vous pouvez ensuite appeler OnMyPropertyChanged(EventArgs.Empty) depuis n’importe où dans cette classe ou en dessous de la hiérarchie d’inheritance pour appeler l’événement.

Je suppose que je ne peux pas accéder à ces événements de la même manière que les autres membres hérités?

Précisément. Il est habituel de fournir une fonction protégée OnXyz ou RaiseXyz pour chaque événement de la classe de base pour permettre la RaiseXyz à partir de classes héritées. Par exemple:

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

Appelé dans la classe héritée:

 OnLoading(); 

Vous pouvez essayer de cette façon, ça marche pour moi:

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