¿Cuál es la diferencia entre un tipo de delegado y un tipo de gestor de eventos?

Question

Tres expresiones relacionadas: evento, delegado, controlador de eventos. Siempre me confundo por quién se "agrega" a quién.

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

Por lo que sé:

• delegado: un puntero a una función con una firma conocida.
• manejador de eventos: un delegado que está registrado en un evento. Básicamente, ¿es lo mismo que un delegado?
• evento: una lista de delegados \ eventos manipuladores que se ejecutan cuando el evento se invoca usando evento()

Lo que me confunde más es esta firma en MSDN:

public delegate void EventHandler(Object sender, EventArgs e) 

Answer 1

Aquí está mi resumen (por favor, corríjanme si me equivoco):

• delegate es un puntero a un método (ejemplo \ estática)

• eventHandler es un delegado con una específica firma (remitente, eventArgs)

• event es una abstracción de acceder a un delegado de cualquier tipo, pero por lo general es un eventHandler por convención

  //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; 
  

quiero recomendar el gran artículo Event Handling in .NET Using C#.

Así que sólo podemos colocar (eventName):

eventName += new TypeName (specificMethodName); 

lo que equivale a (_eventName es un delegado \ eventHandler):

_eventName += new TypeName (specificMethodName); 

Answer 2

El evento tiene un delegate agregado que "señala" a un controlador.

Básicamente, cuando se genera el event, se invocará la colección de delegados que, como resultado, invocará los controladores conectados a esos delegados.

//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" es en realidad sólo acceso directo para dos métodos que funcionan con un delegado - la add and remove accessors. El compilador, de forma predeterminada, hace un delegado detrás del evento (si no escribe sus propios descriptores de acceso).

Cuando llama al someEvent += aDelegate;, llama al acceso add del evento. Normalmente, el compilador lo traduce en una llamada delegate += para un delegado con la misma firma que el evento, similar a cómo las propiedades automáticas se asignan automáticamente a un campo de respaldo. Es por eso que un evento parece tan similar a un delegado.

lo que más me confunde es esta firma en MSDN: delegado public void manejador de sucesos (Object sender, EventArgs e)

Esta firma es sólo una firma del delegado. Un evento puede, técnicamente, usar cualquier delegado. Sin embargo, por convención, siempre tomará dos parámetros: el primero es el "emisor" que provocó el evento, el segundo es una clase que deriva de EventArgs (como EventHandler y EventHandler<T>).