Explicar el código para el evento personalizado en el control de usuario

Question

Alguien me dio este código que funciona muy bien. Pero realmente me gustaría entender qué está sucediendo dentro de él. ¿Podría alguien explicar por favor? ¿Cuál es el significado de cada parte del código? El código está dentro de un control personalizado que tiene dos etiquetas dentro de un panel.

También he visto algunos eventos de control personalizado que usan la sintaxis de agregar/quitar, ¿para qué sirve eso? ¿Cuál es la diferencia con lo que está sucediendo aquí?

public partial class UserControl1 : UserControl 
{ 
    public UserControl1() 
    { 
     InitializeComponent(); 
    } 

    public event EventHandler MyCustomClickEvent; 

    protected virtual void OnMyCustomClickEvent(EventArgs e) 
    { 
     // Here, you use the "this" so it's your own control. You can also 
     // customize the EventArgs to pass something you'd like. 

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

    private void label1_Click(object sender, EventArgs e) 
    { 
     OnMyCustomClickEvent(EventArgs.Empty); 
    } 
} 

Answer 1

Ver mis comentarios a continuación. También para un evento más detallado I blogged sobre este concepto hace un tiempo, donde profundizo en todo el proceso.

public partial class UserControl1 : UserControl 
{ 
    //This is the standard constructor of a user control 
    public UserControl1() 
    { 
     InitializeComponent(); 
    } 

    //This defines an event called "MyCustomClickEvent", which is a generic 
    //event handler. (EventHander is a delegate definition that defines the contract 
    //of what information will be shared by the event. In this case a single parameter 
    //of an EventArgs object. 
    public event EventHandler MyCustomClickEvent; 


    //This method is used to raise the event, when the event should be raised, 
    //this method will check to see if there are any subscribers, if there are, 
    //it raises the event 
    protected virtual void OnMyCustomClickEvent(EventArgs e) 
    { 
     // Here, you use the "this" so it's your own control. You can also 
     // customize the EventArgs to pass something you'd like. 

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

    private void label1_Click(object sender, EventArgs e) 
    { 
     OnMyCustomClickEvent(EventArgs.Empty); 
    } 
} 

Answer 2

Recomiendo leer en Events for C# on MSDN. Esto está cubierto en detalle.

Básicamente, MyCustomClickEvent es un evento. El método OnMyCustomClickEvent se usa para plantear el evento, pero se está haciendo de una manera que las subclases también pueden plantear este evento si es necesario.

Al hacer clic en "label1", se ejecuta el método OnMyCustomClickEvent, lo que provoca el evento. Cualquier delegado suscrito al evento se ejecutará en ese punto.

Answer 3

En cuanto a la función de agregar/quitar, se trata de una implementación "manual" de eventos. Los siguientes dos fragmentos hacen lo mismo.

aplicación automática:

public event EventHandler MyEvent; 

Manual de implementación:

private EventHandler _myEvent; 

public event EventHandler MyEvent 
{ 
    add { _myEvent += value; } 
    remove { _myEvent -= value; } 
} 

Ésta es exactamente la misma idea propiedades como automáticos donde:

public string Property { get; set; }; 

hace exactamente lo mismo que:

private string _property; 

public string Property 
{ 
    get { return _property; } 
    set { _property = value; } 
} 

La diferencia entre estos fragmentos es que con las implementaciones manuales, obtiene más control. Los ejemplos son:

• implementar la lógica en el complemento/obtener y quitar/conjunto;
• Obtenga acceso a los campos que le permiten configurar, p. [NonSerializable];
• Ponga los valores en, p. Ej. a Dictionary.

La clase Form p. Ej. hace esto último para mantener baja la cantidad de campos en la clase Form.

Answer 4

Ha mencionado ver la sintaxis de agregar/quitar eventos en algunos ejemplos de controles personalizados. Lo más probable es esos ejemplos son using the UserControl class' Events property para almacenar controladores de eventos, tales como en el siguiente ejemplo:

public event EventHandler MyEvent 
    { 
     add 
     { 
      Events.AddHandler("MyEvent", value); 
     } 
     remove 
     { 
      Events.RemoveHandler("MyEvent", value); 
     } 
    } 

La idea no es que por lo general un consumidor de un control no va a querer manejar todos los eventos que expone el control .Si cada evento se define como un evento de "campo" (como en su ejemplo), cada evento ocupará un trozo de memoria, incluso si no hay suscriptores para ese evento. Cuando tiene una página compleja construida con cientos de controles, cada uno de los cuales puede tener docenas de eventos, el consumo de memoria para los eventos no utilizados no es insignificante.

Esta es la razón por la cual la clase System.ComponentModel.Component (la clase base de la clase System.Windows.Forms.Control) tiene una propiedad Events, que es básicamente un diccionario para almacenar delegados de controladores de eventos. De esta forma, cada evento se implementa más como una propiedad que como un campo. Los controladores de agregar/eliminar para cada evento almacenan o eliminan delegados del diccionario Events. Si no se utiliza un evento, simplemente no existe una entrada en el diccionario Events, y no se consume memoria adicional para ese evento. Es una desventaja hacer un poco más de trabajo (tener que buscar el controlador de eventos) para ahorrar un poco más de memoria.

EDIT: solucioné mi respuesta para pertenecer a Windows Forms, en lugar de ASP.NET, aunque los conceptos son los mismos.