Qual è la differenza tra un tipo di delegato e un tipo di gestore di eventi?

Question

Tre idiomi correlati: evento, delegato, gestore di eventi. Mi confondo sempre con chi viene "aggiunto" a chi.

event += handler 
event += delegate 
handler += delegate 

Da quello che so:

• delegato: un puntatore a una funzione con una firma nota.
• gestore di eventi: un delegato che è registrato per un evento. Fondamentalmente, è lo stesso di un delegato?
• evento: un elenco di delegati \ Event-gestori che vengono eseguiti quando l'evento viene richiamato tramite eventi()

cosa mi confonde di più è questa firma in MSDN:

public delegate void EventHandler(Object sender, EventArgs e) 

Answer 1

Qui è la mia sintesi (per favore correggetemi se sbaglio):

• delegate è un puntatore ad un metodo (istanza \ statica)

• eventHandler è un delegato con una specifica firma (mittente, eventArgs)

• event è un'astrazione di accesso ad un delegato di qualsiasi tipo, ma di solito è un eventHandler per convenzione

  //We declare delegates as a new type outside of any class scope (can be also inside?) 
  
      public delegate retType TypeName (params...) 
  
  //Here we assign 
  
      public TypeName concreteDeleagteName = new TypeName (specificMethodName); 
  
  //Declaring event 
  //a. taken from http://stackoverflow.com/questions/2923952/explicit-event-add-remove-misunderstood 
  
  private EventHandler _explicitEvent; 
  public event EventHandler ExplicitEvent 
  { 
      add 
      { 
       if (_explicitEvent == null) timer.Start(); 
       _explicitEvent += value; 
      } 
      remove 
      { 
       _explicitEvent -= value; 
       if (_explicitEvent == null) timer.Stop(); 
      } 
  } 
  
  //or: b.auto event - the compiler creates a "hidden" delegate which is bounded to this event 
       public event TypeName eventName; 
  

voglio consigliare il grande articolo Event Handling in .NET Using C#.

Quindi possiamo allegare solo (eventName):

eventName += new TypeName (specificMethodName); 

che è equivalente a (_eventName è un delegato \ EventHandler):

_eventName += new TypeName (specificMethodName); 

Answer 2

L'evento ha aggiunto un delegate che "punta" a un gestore.

Fondamentalmente, quando viene generato il numero event, verrà richiamata la raccolta dei delegati, che come risultato richiamerà i gestori connessi a tali delegati.

//declare delegate 
public delegate void EventHandler( Object sender, EventArgs e) 

//create event based on delegate 
public event EventHandler evHandler; 

//function to attach to handler 
public static void Handler(object sender, EventArgs e) {} 

attach eventhandler function through delegate to event. 
event += new EventHandler(Handler); 

Answer 3

un "evento" è in realtà solo scorciatoia per due metodi che funzionano con un delegato - il add and remove accessors. Il compilatore, per impostazione predefinita, rende un delegato dietro l'evento (se non si scrivono i propri metodi di accesso).

Quando si chiama someEvent += aDelegate;, si chiama l'accessore dell'evento add. Normalmente, questo viene tradotto dal compilatore in una chiamata delegate += per un delegato con la stessa firma dell'evento - simile a come le proprietà automatiche si associano automaticamente a un campo di supporto. Questo è il motivo per cui un evento sembra così simile a un delegato.

quello che mi ha più confonde è questa firma in MSDN: Delegato pubblico EventHandler void (Object sender, EventArgs e)

Questa firma è solo una firma del delegato. Un evento può, tecnicamente, utilizzare qualsiasi delegato. Tuttavia, per convenzione, prenderà sempre due parametri: il primo è il "mittente" che ha generato l'evento, il secondo è una classe che deriva da EventArgs (come EventHandler e EventHandler<T>).