C#: Sensibilisation hérité d'un événement

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 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.Chargement ne peut apparaître sur le côté gauche de l' += ou -= (BaseClass')

Je suis en supposant que je ne peut pas accéder à ces événements, le même que les autres les membres hérités?

InformationsquelleAutor jwarzech | 2009-04-16

c#events inheritance

149

Ce que vous avez à faire , c'est ceci:

Dans votre classe de base (où vous avez déclaré que les événements), créer protégé des méthodes qui peuvent être utilisées pour lever 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 devrez probablement changer de ces méthodes, afin de vérifier si vous avez d'Invoquer le gestionnaire ou pas).

Puis, dans les classes qui héritent de cette classe de base, vous pouvez simplement appeler le OnFinished ou OnLoading méthodes pour élever les événements:
```
public AnotherClass : MyClass
{
    public void DoSomeStuff()
    {
        ...
        OnLoading(EventArgs.Empty);
        ...
        OnFinished(EventArgs.Empty);
    }
}
```
- Ces méthodes doivent être protégés virtuel, sauf si il y a une bonne raison de faire autrement.
- Pourquoi devrait-elle être virtuelle ? Je voudrais déclarer virtuelle si je voulais héritiers de changer la façon dont l'événement doit être soulevée, mais la plupart du temps, je ne vois aucune raison de le faire ...
- Par des lignes directrices Microsoft dit qu'il devrait être virtuel, de sorte que inheritants pouvez contrôler l'événement.. en outre, les protégées de la méthode de l'événement args, ne pas les créer lui-même. Cette réponse est fausse par rapport à la corriger l'un par Adam Robinson.
- La convention pour les héritiers la gestion des événements est d'annuler l'événement de collecte plutôt que de s'attacher eux-mêmes, en tant que a) le polymorphisme est (légèrement) plus efficace qu'un délégué multicast, et b) il leur donne le contrôle sur quand leur code est exécuté (c'est à dire avant ou après l'abonné code)
- Les instructions officielles: msdn.microsoft.com/en-us/library/w369ty8x(SV.80).aspx
- meandmycode: en ce qui concerne les arguments: c'est juste un exemple de code. Offcourse il est préférable de les passer comme arguments ... je vais la changer si elle vous rend heureux. :o:
- Concernant ce qui rend la méthode virtuelle, de sorte que les héritiers peuvent remplacer le cas d'invocation de comportement: Combien de fois avez-vous été dans une situation où c'était nécessaire ? À côté de cela; dans le remplacé méthode, vous ne pouvez pas déclencher l'événement, puisque vous obtiendrez la même erreur que celle mentionnée par TS.
- Frederik, vous pouvez obtenir l'erreur que vous appelez de base.Sur~
- Oui, vous pouvez augmenter en appelant la base de la mise en œuvre. Mais quelles sont les autres fonctionnalités supplémentaires, pouvez-vous penser ?
- Comme indiqué précédemment, de contrôler si VOTRE code est exécuté avant ou après le code de l'événement abonnés. - Je faire cela sur une base régulière.
- Je l'ai suivi parce que le raisonnement est le son, selon la façon dont réutilisables et extensibles j'attends le code, j'ai fourni des lignes directrices officielles pour accompagner cela.. au moment de la rédaction vous semblent également très nouveau .NET Verax donc c'est un peu déroutant que vous avez creusé pour en désaccord avec mon expérience de 7 ans
InformationsquelleAutor Frederik Gheysels
119

Vous ne pouvez accéder à un événement dans la classe de déclaration, comme .NET crée des variables d'instance privé derrière les scènes qui détiennent effectivement le délégué. Faire 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 de...
```
MyPropertyChanged(this, EventArgs.Empty);
```
est en fait...
```
myPropertyChangedDelegate(this, EventArgs.Empty);
```
De sorte que vous pouvez (évidemment), seul l'accès privé instance de délégué de la variable dans la classe de déclaration.

La convention est de fournir quelque chose comme cela dans la classe de déclaration..
```
protected virtual void OnMyPropertyChanged(EventArgs e)
{
    EventHandler invoker = MyPropertyChanged;

    if(invoker != null) invoker(this, e);
}
```
Vous pouvez ensuite appeler OnMyPropertyChanged(EventArgs.Empty) à partir de n'importe où dans la classe ou au-dessous de la hiérarchie d'héritage d'invoquer l'événement.
- J'ai eu quelques problèmes de mise en œuvre de cette... stackoverflow.com/q/10593632/328397
- Je préfère cette réponse car il explique POURQUOI vous devez utiliser l'approche au lieu de l'approche. Beau travail.
InformationsquelleAutor Adam Robinson
8

Je suis en supposant que je ne peut pas accéder à ces événements, le même que les autres les membres hérités?

Précisément. Il est d'usage de fournir une fonction protégée OnXyz ou RaiseXyz pour chaque événement dans la classe de base pour permettre à élever les 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();
```
InformationsquelleAutor Konrad Rudolph

Vous pouvez essayer de cette façon, Ça fonctionne 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);
    }
}

Notez que cet article met en garde contre de déclarer des événements virtuels et de leur remplaçant, comme il le prétend le compilateur ne gère pas correctement ceci: msdn.microsoft.com/en-us/library/hy3sefw3.aspx

InformationsquelleAutor Olioul Islam Rahi

0

pas de ressusciter un vieux thread mais dans le cas où quelqu'un est à la recherche, ce que j'ai fait était
```
protected EventHandler myPropertyChangedDelegate;

public event EventHandler MyPropertyChanged
{
    add { myPropertyChangedDelegate += value; }
    remove { myPropertyChangedDelegate -= value; }
}
```
Cela vous permet d'hériter de l'événement dans une classe dérivée de sorte que vous pouvez l'invoquer sans nécessiter d'envelopper la méthode tout en gardant la syntaxe+=. Je suppose qu'on peut toujours le faire avec l'emballage méthodes si vous n'avez
```
public event EventHandler MyPropertyChanged
{
   add { AddDelegate(value); }
   remove { RemoveDelegate(value); }
}
```
InformationsquelleAutor Zeraphil

Vous devez vous connecter pour publier un commentaire.