Instrucciones de uso de eventos

Artículo
04/11/2008

En las reglas siguientes se describen las instrucciones de uso de eventos:

Elija un nombre para el evento siguiendo las Instrucciones de nomenclatura de eventos recomendadas.
Cuando haga referencia a eventos en la documentación, utilice la frase, "se provocó un evento", en vez de "se activó un evento" o "se desencadenó un evento".
En los lenguajes que admiten la palabra clave void, utilice el tipo de valor devuelto de void para los controladores de eventos, como se muestra en el siguiente código en lenguaje C# de ejemplo.
```
public delegate void MouseEventHandler(object sender, MouseEventArgs e);
```
Cuando un evento contenga datos importantes, tales como las coordenadas de un clic del mouse (ratón), use clases de datos de eventos con establecimiento inflexible de tipos.

Las clases de eventos deben extender la Clase System.EventArgs, como se muestra en el ejemplo siguiente.

Public Class MouseEventArgs
   Inherits EventArgs 
   ' Code for the class goes here.
End Class
[C#]
public class MouseEvent: EventArgs {}

Utilice un método virtual protected (Protected en Visual Basic) para provocar cada evento. Esta técnica no es adecuada para clases sealed porque no permiten derivar ninguna clase. La finalidad de este método es proporcionar a una clase derivada una forma de controlar el evento mediante un reemplazo. Esto es más natural que utilizar delegados en las situaciones en las que el programador crea una clase derivada. El nombre del método se convierte en OnEventName, donde EventName es el nombre del evento provocado. Por ejemplo:
```
Public Class Button
   Private onClickHandler As ButtonClickHandler  
   Protected Overridable Sub OnClick(e As ClickEventArgs)
      ' Call the delegate if non-null.
      If Not (onClickHandler Is Nothing) Then
         onClickHandler(Me, e)
      End If 
   End Sub
End Class

[C#]
public class Button 
{
   ButtonClickHandler onClickHandler;

   protected virtual void OnClick(ClickEventArgs e) 
   {
      // Call the delegate if non-null.
      if (onClickHandler != null)
            onClickHandler(this, e);      
   }
}
```
La clase derivada puede elegir no llamar a la clase base durante el procesamiento de OnEventName. Teniendo en cuenta esto, no incluya ningún procesamiento en el método OnEventName que sea necesario para que la clase base funcione correctamente.

Hay que tener en cuenta que un controlador de eventos puede contener cualquier código. Las clases deben estar preparadas para que el controlador de eventos realice cualquier operación y, en todos los casos, el objeto debe tener el estado adecuado, una vez provocado el evento. Considere la utilización de un bloque try/finally en el punto del código donde se provoca el evento. Como el programador puede realizar una función de devolución de llamada en el objeto para realizar otras acciones, no haga suposiciones sobre el estado del objeto cuando el control regrese al punto en el que provocó el evento. Por ejemplo:

Public Class Button
   Private onClickHandler As ButtonClickHandler
   Protected Sub DoClick()
      ' Paint button in indented state.      
      PaintDown()
      Try
         ' Call event handler.
         OnClick()      
      Finally
         ' Window might be deleted in event handler.
         If Not (windowHandle Is Nothing) Then
            ' Paint button in normal state.
            PaintUp()
         End If 
      End Try
   End Sub
   Protected Overridable Sub OnClick(e As ClickEvent)
      If Not (onClickHandler Is Nothing) Then
         onClickHandler(Me, e)
      End If
   End Sub
End Class
[C#]
public class Button
{
   ButtonClickHandler onClickHandler;

   protected void DoClick()
   {
      // Paint button in indented state.
      PaintDown();
         try
      {
         // Call event handler.
         OnClick();         
      }
      finally
      {
         // Window might be deleted in event handler.
         if (windowHandle != null)
            // Paint button in normal state.
            PaintUp();            
      }
   }

   protected virtual void OnClick(ClickEvent e)
   {
      if (onClickHandler != null)
         onClickHandler(this, e);
   }
}

Utilice o extienda la Clase System.ComponentModel.CancelEventArgs para permitir que el programador controle los eventos de un objeto. Por ejemplo, el control TreeView provoca BeforeLabelEdit cuando el usuario se dispone a editar una etiqueta de nodo. En el siguiente ejemplo de código se muestra cómo puede utilizar un programador este evento para evitar la edición de un nodo.
```
Public Class Form1
   Inherits Form
   Private treeView1 As New TreeView() 

   Sub treeView1_BeforeLabelEdit(source As Object, e As NodeLabelEditEventArgs)
      e.CancelEdit = True
   End Sub
End Class
[C#]
public class Form1: Form 
{
   TreeView treeView1 = new TreeView();

   void treeView1_BeforeLabelEdit(object source, 
      NodeLabelEditEventArgs e) 
   {
      e.CancelEdit = true;
   }
}
```
Observe que en este caso, no se genera un error. Se trata de una etiqueta de sólo lectura.

Cancelar eventos no resulta adecuado en los casos en que el programador cancelaría la operación y devolvería una excepción. En estos casos, se debe provocar una excepción dentro del controlador de eventos para cancelarlos. Por ejemplo, supongamos que el usuario desea escribir lógica de validación en un control de edición como se muestra a continuación.
```
Public Class Form1
   Inherits Form
   Private edit1 As EditBox = New EditBox() 

   Sub TextChanging(source As Object, e As EventArgs)
      Throw New RuntimeException("Invalid edit")
   End Sub
End Class
[C#]
public class Form1: Form 
{
   EditBox edit1 = new EditBox();

   void TextChanging(object source, EventArgs e) 
   {
      throw new RuntimeException("Invalid edit");
   }
```

Vea también

Instrucciones de diseño para programadores de bibliotecas de clases | Instrucciones de nomenclatura de eventos | Instrucciones de uso de miembros de clases

Share via

Instrucciones de uso de eventos

Vea también

Recursos adicionales