Cómo: Implementar eventos en una clase

Actualización: noviembre 2007

Los siguientes procedimientos describen cómo implementar un evento en una clase. El primer procedimiento implementa un evento que no tiene datos asociados; utiliza las clases System.EventArgs y System.EventHandler para los datos de eventos y el controlador de delegados. El segundo procedimiento implementa un evento con datos personalizados; define las clases personalizadas para los datos de evento y el controlador del delegado de eventos.

Para consultar un ejemplo completo de cómo provocar y controlar eventos, vea Cómo: Provocar y consumir eventos.

Para implementar un evento sin datos específicos del evento

1. Defina un miembro de evento público en la clase. Establezca el tipo del miembro de evento en un delegado System.EventHandler.

   public class Countdown 
   {
       ...
       public event EventHandler CountdownCompleted;   
   }
   

   Public Class Countdown
       ...
       Public Event CountdownCompleted As EventHandler
   End Class
   

2. Incluya en la clase un método protegido que provoque el evento. Dé un nombre al método OnEventName. Provoque el evento dentro del método.

   public class Countdown 
   {
       ...
       public event EventHandler CountdownCompleted;   
       protected virtual void OnCountdownCompleted(EventArgs e)    {        if (CountdownCompleted != null)            CountdownCompleted(this, e);    }
   }
   

   Public Class Countdown
      ...
      Public Event CountdownCompleted As EventHandler
      Protected Overridable Sub OnCountdownCompleted(e As EventArgs)      RaiseEvent CountdownCompleted(Me, e)   End Sub
   End Class
   

3. Determine cuándo provocar el evento en la clase. Llame a OnEventName para provocar el evento.

   public class Countdown 
   {
       ...
       public void Decrement
       {
           internalCounter = internalCounter - 1;
           if (internalCounter == 0)
               OnCountdownCompleted(new EventArgs());
       }
   }
   

   Public Class Countdown
       ...
       Public Function Decrement
           InternalCounter = internalCounter - 1
           If internalCounter = 0
               OnCountdownComplete(New EventArgs())
           End If
       End Function
   End Class
   

Para implementar un evento con datos específicos del evento

1. Defina una clase que proporcione los datos del evento. Dé un nombre a la clase EventNameArgs, derive la clase de System.EventArgs y agregue los miembros específicos del evento.

   public class AlarmEventArgs : EventArgs 
   {
      private readonly int nrings = 0;
      private readonly bool snoozePressed = false;
   
      //Constructor.
      public AlarmEventArgs(bool snoozePressed, int nrings) 
      {
         this.snoozePressed = snoozePressed;
         this.nrings = nrings;
      }
   
      //Properties.
      public string AlarmText {  
         ...
      }
      public int NumRings {
         ...
      }
      public bool SnoozePressed{
         ...
      }
   }
   

   Public Class AlarmEventArgs
      Inherits EventArgs
      Private nrings As Integer = 0
      Private _snoozePressed As Boolean = False
   
      'Constructor.
      Public Sub New(ByVal snoozePressed As Boolean, ByVal nrings As Integer) 
         Me.snoozePressed = snoozePressed
         Me.nrings = nrings
      End Sub
   
      'Properties.
      Public ReadOnly Property AlarmText() As String
         ...
      End Property 
   
      Public ReadOnly Property NumRings() As Integer
         ...
      End Property 
   
      Public ReadOnly Property SnoozePressed() As Boolean
         ...
      End Property
   End Class
   

2. Declare un delegado para el evento. Dé un nombre al delegado EventNameEventHandler.

   public delegate void AlarmEventHandler(object sender, AlarmEventArgs e);
   

   Public Delegate Sub AlarmEventHandler(sender As Object, e As AlarmEventArgs)
   

3. Defina un miembro de evento público denominado EventName en la clase. Establezca el tipo del miembro de evento en el tipo de delegado de eventos.

   public class AlarmClock 
   {
       ...
       public event AlarmEventHandler Alarm;
   }
   

   Public Class AlarmClock
       ...
       Public Event Alarm As AlarmEventHandler
   End Class
   

4. Defina en la clase un método protegido que provoque el evento. Dé un nombre al método OnEventName. Provoque el evento dentro del método.

   public class AlarmClock 
   {
       ...
       public event AlarmHandler Alarm;
       protected virtual void OnAlarm(AlarmEventArgs e)    {      if (Alarm != null)           Alarm(this, e);     }
   }
   

   Public Class AlarmClock
       ...
       Public Event Alarm As AlarmEventHandler
       Protected Overridable Sub OnAlarm(e As AlarmEventArgs)        RaiseEvent Alarm(Me, e)    End Sub
   End Class
   

5. Determine cuándo provocar el evento en la clase. Llame a OnEventName para provocar el evento y pase los datos específicos del evento utilizando EventNameEventArgs.

   Public Class AlarmClock
   {
       ...
       public void Start()
       {
           ...
           System.Threading.Thread.Sleep(300);
           AlarmEventArgs e = new AlarmEventArgs(false, 0);
           OnAlarm(e);
       }
   }
   

   Public Class AlarmClock
       ...
       Public Function Start
           ...
           System.Threading.Thread.Sleep(300)
           Dim e As AlarmEventArgs = New AlarmEventArgs(False, 0)
           OnAlarm(e)
       End Function
   End Class
   

Vea también

Tareas

Cómo: Provocar y utilizar eventos

Conceptos

Eventos y delegados

Provocar un evento

Otros recursos

Controlar y provocar eventos