Différence entre événements et méthodes

Une méthode est simplement un code contenu dans une classe pour implémenter un morceau de fonctionnalité. Tout le code en C # est contenu dans les méthodes.

Quant aux événements, Eh bien, supposons que vous ayez une classe simple qui a mis en œuvre un compteur (appelez-le le compteur code> objet code>). Supposons maintenant que vous vouliez laisser les autres objets non liés à compteur code> savoir quand le compte atteint 100. Comment le feriez-vous? p>

une manière logique serait de permettre aux autres objets de spécifier l'un de leurs méthodes em> possédant les em> qu'ils souhaitent être appelés lorsque le nombre atteint 100. Chaque objet pourrait alors, individuellement, dire L'objet code> compteur code> Quelle méthode qu'ils veulent être appelées. Le compteur code> enregistre cette liste de méthodes et, lorsque le nombre atteint 100, appelle chacune des méthodes enregistrées à son tour. P>

C'est la façon dont les événements fonctionnent - le Compteur code> Classe contient un membre de l'événement (appelé dites, compteur 100 code>) quels autres instances d'objet relient l'une de leurs propres méthodes à. Lorsque l'objet code> code> détecte qu'il a atteint 100, il invoque em> l'élément compteur code> membre qui appelle automatiquement toutes les méthodes actuellement liées à celle-ci. , notifiant ainsi chaque objet à son tour que le comte a effectivement atteint 100. Si aucun objet n'a lié à une méthode de l'élément d'événement de contre-un, il sera null code>, il n'y a donc pas besoin de l'objet code> compteur code> d'invoquer l'élément d'événement. P >

class Counter
{
   // this is the count field used to save the current count value
   private int count;

   // this is the event member which holds all the methods other objects have specified
   public event CounterIs100Delegate CounterIs100;

   // This is a method. It invokes the CounterIs100 event member if anyone has subscribed to it
   protected void OnCounterIs100()
   {
       // see if anyone has subscribed (linked) their method to this event
       if (CounterIs100 != null)
       {
          // invoke the event - this will call all subscribed methods
          CounterIs100();
       }
   }

   // This is a method. It increments the counter variable stored by this object
   public void Increment()
   {
      count++;
      // if the count is 100, invoke the event
      if (count == 100)
         OnCounterIs100();
   }

}

// This is a delegate. It is used to define a template for other objects wishing to
// subscribe to the CounterIs100 event. The methods other objects link to the
// CounterIs100 event must match this declaration (although the name can be changed)
public delegate void CounterIs100Delegate();

// This is a class, unrelated to Counter, but uses its events
class SiteHits
{
     Counter hitCounter = new Counter();

     public SiteHits()
     {
         // We want to know when the number of site hits reaches 100.
         // We could monitor this ourselves, but we know the Counter class already
         // does this, so we just link our method to its event
         hitCounter.CounterIs100 += this.WhenSiteHitsReaches100;
     }

     public void PageRequested()
     {
         // someone has requested a page - increment the hit counter
         Console.WriteLine("We've been hit!");
         hitCounter.Increment();            
     }

     // this is the method we want called when the CounterIs100 event occurs.
     // note that the return value and parameters match CounterIs100Delegate above.
     public void WhenSiteHitsReaches100()
     {
         Console.WriteLine("Woohoo! We've reached 100 hits!");
     }
}

c # Events est une forme spécifique de délégués . Si vous avez programmé dans d'autres langues, comme C ++, vous pouvez comparer un délégué à une fonction ("méthode") pointeur - cela pointe sur un code en mémoire. Lorsque vous appelez le pointeur sous forme de méthode, vous appelez réellement la méthode à l'adresse indiquée par le pointeur.

Ceci est nécessaire pour fournir un découplage entre l'appelant et la callee - de sorte que vous ne devez pas avoir toutes les méthodes prêtes lorsque vous publiez du code qui les appelle (qui, qui, ne serait pas possible - les formulaires contrôlent les développeurs ne peuvent pas Connaissez-vous peut-être le code qui doit être appelé lorsqu'un bouton est enfoncé). Vous appelez le pointeur et l'autre développeur le définit à une adresse mémoire appropriée ultérieurement.

P.s. Les délégués et Evénements ont cependant d'autres avantages sur les pointeurs de fonction uni - vous pouvez être sûr qu'il indiquera une méthode bien jolie, en prenant le bon nombre et le type d'arguments. et retourner le type correct.