C#: Raising un événement hérité

Question

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 que je tente de soulever 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 sur le côté gauche de + = ou - = (BaseClass')

Je suppose que je ne peux pas accéder à ces événements les mêmes que d'autres membres hérités?

Answer 1

Qu'est-ce que vous avez à faire, est la suivante:

Dans votre classe de base (où vous avez déclaré les événements), créer 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 meth ods, afin de vérifier si vous devez appeler l'eventhandler ou non).

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

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

Answer 2

I am assuming I cannot access these events the same as other inherited members?

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 afin de permettre l'augmentation des 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(); 

Answer 3

Vous ne pouvez accéder à un événement dans la classe déclarant, comme .NET crée des variables d'instance privées derrière les scènes qui contiennent réellement le délégué. En faisant cela ..

public event EventHandler MyPropertyChanged; 

est en train de faire cela;

private EventHandler myPropertyChangedDelegate; 

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

et le faire ...

MyPropertyChanged(this, EventArgs.Empty); 

est en fait ce ...

myPropertyChangedDelegate(this, EventArgs.Empty); 

Vous pouvez donc (évidemment) accéder uniquement à la variable d'instance de délégué privé à l'intérieur du déclarant classe.

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

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

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

Vous pouvez ensuite appeler OnMyPropertyChanged(EventArgs.Empty) de partout dans cette classe ou au-dessous de l'héritage hiérarchisé pour invoquer l'événement.

Answer 4

Vous pouvez essayer 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); 
    } 
}