Exportar (0) Imprimir
Expandir todo

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
    

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft