Eventos (Visual Basic)

A pesar de que se puede visualizar un proyecto de Visual Studio como una serie de procedimientos que se ejecutan consecutivamente, en realidad la mayoría de los programas están dirigidos por eventos, es decir, el flujo de ejecución está determinado por elementos externos denominados eventos.

Un evento es una señal que comunica a una aplicación que ha sucedido algo importante. Por ejemplo, cuando un usuario hace clic en un control de un formulario, el formulario puede provocar un evento Click y llamar a un procedimiento que controla el evento. Los eventos también permiten que las tareas separadas se comuniquen. Suponga, por ejemplo, que una aplicación realiza una tarea de ordenación independientemente de la aplicación principal. Si un usuario cancela la ordenación, la aplicación puede enviar un evento de cancelación que ordene la detención del proceso de ordenación.

Conceptos y términos de los eventos

Esta sección describe los términos y conceptos que se utilizan con eventos en Visual Basic.

Declarar eventos

Los eventos se declaran en clases, estructuras, módulos e interfaces mediante la palabra clave Event, como se muestra en el siguiente ejemplo:

Event AnEvent(ByVal EventNumber As Integer)

Producir eventos

Un evento es como un mensaje que anuncia que ha pasado algo importante. A la acción de difundir el mensaje se le llama producir el evento. En Visual Basic, los eventos se generan con la instrucción RaiseEvent, como en el ejemplo siguiente:

RaiseEvent AnEvent(EventNumber)

Los eventos se deben provocar dentro del ámbito de la clase, módulo o estructura donde se declaran. Por ejemplo, una clase derivada no puede producir eventos heredados de una clase base.

Remitentes de eventos

Cualquier objeto capaz de producir un evento es un remitente de eventos, y también recibe el nombre de origen de eventos. Los formularios, controles y objetos definidos por el usuario son ejemplos de remitentes de eventos.

Controladores de eventos

Los controladores de eventos son procedimientos llamados cuando se produce un evento correspondiente. Puede utilizar cualquier subrutina válida con una firma coincidente como controlador de eventos. No obstante, no puede utilizar una función como controlador de eventos, porque no puede devolver un valor al origen del evento.

Visual Basic utiliza una convención de nomenclatura estándar para controladores de eventos que combina el nombre del remitente del evento, un signo de subrayado y el nombre del evento. Por ejemplo, el evento Click de un botón denominado button1 recibiría el nombre de Sub button1_Click.

Nota
Es recomendable utilizar esta convención de nomenclatura al definir controladores de eventos para sus propios eventos, pero no es estrictamente necesario; puede utilizar cualquier nombre de subrutina válido.

Asociar eventos a controladores de eventos

Para que un controlador de eventos se pueda utilizar, primero debe asociarse a un evento mediante la instrucción Handles o AddHandler.

WithEvents y la cláusula Handles

La instrucción WithEvents y la cláusula Handles proporcionan una forma declarativa de especificar controladores de eventos. Los eventos provocados por un objeto declarado con la palabra clave WithEvents pueden controlarse mediante cualquier procedimiento con una instrucción Handles para ese evento, tal y como se muestra en el ejemplo siguiente:

' Declare a WithEvents variable. 
Dim WithEvents EClass As New EventClass

' Call the method that raises the object's events. 
Sub TestEvents()
    EClass.RaiseEvents()
End Sub 

' Declare an event handler that handles multiple events. 
Sub EClass_EventHandler() Handles EClass.XEvent, EClass.YEvent
    MsgBox("Received Event.")
End Sub 

Class EventClass
    Public Event XEvent()
    Public Event YEvent()
    ' RaiseEvents raises both events. 
    Sub RaiseEvents()
        RaiseEvent XEvent()
        RaiseEvent YEvent()
    End Sub 
End Class

La instrucción WithEvents y la cláusula Handles son a menudo la mejor opción para los controladores de eventos, ya que la sintaxis declarativa que utilizan hace que el control de eventos sea más sencillo de codificar, leer y depurar. No obstante, tenga en cuenta las siguientes limitaciones en la utilización de las variables WithEvents:

• No se puede utilizar una variable WithEvents como variable de objeto. Es decir, no es posible declararla como Object; se debe especificar el nombre de clase al declarar la variable.

• Dado que los eventos compartidos no están asociados a instancias de clase, no se puede usar WithEvents para controlar eventos compartidos mediante declaración. De forma parecida, no se puede utilizar WithEvents ni Handles para controlar los eventos desde una estructura Structure. En ambos casos, puede utilizar la instrucción AddHandler para controlar esos eventos.

• No se pueden crear matrices de variables WithEvents.

Las variables WithEvents permiten que un solo controlador controle uno o más tipos de eventos, así como que uno o más controladores de eventos controlen el mismo tipo de evento.

Aunque la cláusula Handles es la forma estándar de asociar un evento a un controlador de eventos, está limitada a asociar eventos a controladores de eventos en tiempo de compilación.

En algunos casos, como con eventos asociados a formularios o controles, Visual Basic desactiva automáticamente un controlador de eventos vacío y lo asocia a un evento. Por ejemplo, al hacer doble clic en un botón de comando en un formulario en modo de diseño, Visual Basic crea un controlador de eventos vacío y una variable WithEvents para el botón de comando, como en el código siguiente:

Friend WithEvents Button1 As System.Windows.Forms.Button
Protected Sub Button1_Click() Handles Button1.Click
End Sub

AddHandler y RemoveHandler

La instrucción AddHandler se parece a la cláusula Handles en que las dos permiten especificar un controlador de eventos. Sin embargo, AddHandler, utilizado con RemoveHandler, proporciona más flexibilidad que la cláusula Handles, lo que permite agregar, quitar y cambiar de forma dinámica el controlador de errores asociado con un evento. Si desea controlar eventos compartidos o eventos de una estructura, debe utilizar AddHandler.

AddHandler toma dos argumentos: el nombre de un evento de un remitente de evento, como un control, y una expresión que evalúa a un delegado. No necesita especificar explícitamente la clase delegada al utilizar AddHandler, ya que la instrucción AddressOf siempre devuelve una referencia al delegado. El ejemplo siguiente asocia un controlador de eventos a un evento provocado por un objeto:

AddHandler Obj.XEvent, AddressOf Me.XEventHandler

RemoveHandler, que desconecta un evento de un controlador de eventos, utiliza la misma sintaxis que AddHandler. Por ejemplo:

RemoveHandler Obj.XEvent, AddressOf Me.XEventHandler

En el ejemplo siguiente, un controlador de eventos se asocia a un evento y se genera el evento. El controlador de eventos detecta el evento y muestra un mensaje.

A continuación, se quita el primer controlador de eventos y se asocia al evento un controlador de eventos diferente. Cuando el evento se vuelve a generar, se muestra un mensaje diferente.

Finalmente, se quita el segundo controlador de eventos y el evento se genera por tercera vez. Dado que ya no hay ningún controlador de eventos asociado al evento, no se realiza ninguna acción.

Module Module1

    Sub Main()
        Dim c1 As New Class1
        ' Associate an event handler with an event. 
        AddHandler c1.AnEvent, AddressOf EventHandler1
        ' Call a method to raise the event.
        c1.CauseTheEvent()
        ' Stop handling the event. 
        RemoveHandler c1.AnEvent, AddressOf EventHandler1
        ' Now associate a different event handler with the event. 
        AddHandler c1.AnEvent, AddressOf EventHandler2
        ' Call a method to raise the event.
        c1.CauseTheEvent()
        ' Stop handling the event. 
        RemoveHandler c1.AnEvent, AddressOf EventHandler2
        ' This event will not be handled.
        c1.CauseTheEvent()
    End Sub 

    Sub EventHandler1()
        ' Handle the event.
        MsgBox("EventHandler1 caught event.")
    End Sub 

    Sub EventHandler2()
        ' Handle the event.
        MsgBox("EventHandler2 caught event.")
    End Sub 

    Public Class Class1
        ' Declare an event. 
        Public Event AnEvent()
        Sub CauseTheEvent()
            ' Raise an event. 
            RaiseEvent AnEvent()
        End Sub 
    End Class 

End Module

Controlar eventos heredados de una clase base

Las clases derivadas (clases que heredan características de una clase base) pueden controlar eventos provocados por su clase base mediante la instrucción Handles MyBase.

Controlar eventos de una clase base

• Declare un controlador de eventos en la clase derivada agregando una instrucción Handles MyBase.nombreDeEvento a la línea de declaración del procedimiento controlador de eventos, donde nombreDeEvento es el nombre del evento de la clase base que está controlando. Por ejemplo:

  Public Class BaseClass
      Public Event BaseEvent(ByVal i As Integer)
      ' Place methods and properties here. 
  End Class 
  
  Public Class DerivedClass
      Inherits BaseClass
      Sub EventHandler(ByVal x As Integer) Handles MyBase.BaseEvent
          ' Place code to handle events from BaseClass here. 
      End Sub 
  End Class
  

Secciones relacionadas