Equivalencias entre Visual Basic y Visual C# (4)

En esta ocasión será sobre cómo definir, lanzar e interceptar eventos.

1. Definir eventos
   • Definir eventos en Visual Basic sin usar delegados
   • Definir eventos en Visual Basic usando delegados
   • Definir eventos en Visual C# (siempre usando delegados)
2. Lanzar eventos
   • Lanzar un evento en Visual Basic
   • Lanzar un evento en C#
3. Interceptar eventos
   • Ligar un método de evento en Visual Basic usando WithEvents y Handles
   • Ligar un método de evento en Visual Basic usando AddHandler
   • Ligar un método de evento en C#
     • Usando la versión larga, válida para cualquier versión de C#
     • Usando la versión corta, válida para C# 2.0 (2005) o superior
   • Desligar un método de un evento

1- Definir eventos

Los eventos en Visual Basic se pueden definir de dos formas distintas, según usemos delegados o no.
En Visual C# solo se pueden definir a la forma del propio .NET, es decir, usando delegados.

Definir eventos en Visual Basic sin usar delegados

(al estilo de como se hace en todas las versiones de Visual Basic, incluso las que no son de .NET)

Public Event MiEvento(ByVal param1 As String, ByVal param2 As Integer)

Nota:
Hay que tener en cuenta que el propio compilador de Visual Basic creará un delegado para cada uno de los eventos que definamos de esta forma. A esos delegados le dará el nombre "recomendado", que en en nuestro ejemplo será MiEventoEventHandler.

Definir eventos en Visual Basic usando delegados

Primero debemos definir el delegado (que debe tener un ámbito igual o superior que el evento).
El delegado normalmente será de tipo Sub y se definirá con los parámetros que queramos que tenga el evento.

Public Delegate Sub MiEventoEventHandler(ByVal param1 As String, ByVal param2 As Integer)

Después definimos el evento pero indicando que se usará el delegado, es decir, lo definimos como si fuera una variable con el mismo tipo que el delegado:

Public Event MiEvento As MiEventoEventHandler

Nota:
Como veremos después, se defina el evento con o sin delegado, la forma de lanzarlo será la misma.

Definir eventos en Visual C# (siempre usando delegados)

El delegado lo definimos de la siguiente forma:

public delegate void MiEventoEventHandler(string param1, int param2);

Y el evento lo definimos del tipo del delegado:

public event MiEventoEventHandler MiEvento;

Nota:
En Visual C#, el delegado lo deberíamos definir siempre a nivel de espacio de nombres, es decir, en el mismo nivel que la clase, no dentro de la propia clase. Ya que a diferencia de Visual Basic, en C# siempre se necesita acceder al delegado para poder interceptarlo, y si lo definimos dentro de la clase, la forma de definir el método será diferente.

2- Lanzar eventos

Para lanzar un evento (hacer que se produzca), siempre lo tendremos que hacer desde la propia clase, aunque si definimos un método que sea el encargado de producir dicho evento, (que es como se recomienda en la documentación de Visual Studio), podremos lanzarlo desde cualquier sitio desde el que se tenga acceso a ese método.
Pero para simplificar, (y evitar problemas), lo mejor es que pensemos que el evento solo lo podemos lanzar desde la propia clase en la que lo definimos.

Lanzar un evento en Visual Basic:

La forma de lanzar un evento en Visual Basic, se hace siempre de la misma forma, lo hayamos definido con un delegado o sin el delegado.
La forma de lanzarlo se hace de la misma forma sea la versión que sea (para .NET o no).
Y es usando la instrucción RaiseEvent seguida del evento y los parámetros que tenga dicho evento (o el delegado que hayamos definido).
En nuestro ejemplo, lo podemos lanzar de esta forma:

Public Sub Mostrar(ByVal nombre As String, ByVal edad As Integer)

    RaiseEvent MiEvento(nombre, edad)

    ' ... resto del código ...
End Sub

En este caso, lo lanzamos desde un método que recibe los parámetros que vamos a usar en el evento, pero la instrucción RaiseEvent la podemos usar en cualquier otro método o propiedad de nuestra clase.

Nota:
Cuando estamos escribiendo el código en el editor de Visual Basic, después de escribir la instrucción RaiseEvent, nos mostrará los eventos que tenemos definidos en la clase y al elegir un evento también nos mostrará los parámetros adecuados a ese evento.

Lanzar un evento en C#:

En C#, la forma de lanzar un evento es como cuando usamos cualquier delegado, pero antes de lanzarlo (o llamar al delegado), debemos comprobar si en realidad se está usando en algún lado ese evento, por tanto debemos comprobar si la variable del evento es un valor nulo o no, en caso de que no sea un valor nulo, es que lo podemos lanzar.

public void Mostrar(string nombre, int edad)
{
    // En C# debemos comprobar que el evento no sea null
    if (MiEvento != null)
    {
        // El evento se lanza como cualquier delegado
        MiEvento(nombre, edad);
    }

    // ... resto del código ... 
}

3- Interceptar eventos

Para interceptar un evento debemos definir un método que tenga la misma "firma" que el delegado asociado a ese evento, es decir, debe ser del mismo tipo y tener los mismos parámetros.
En caso de que en VB hayamos definido el evento sin delegado, ese método debe tener los mismos parámetros que recibirá el evento.

Una vez que tenemos el método definido, lo debemos "ligar" con el evento.

En Visual Basic, esa "ligadura" podemos hacerla de dos formas, dependiendo de cómo hayamos definido la variable de la clase que define el evento.
En C# la forma de ligar el evento siempre es mediante el operador += y dependiendo de la versión de .NET que estemos usando se podrá definir de una forma o de otra. Ahora veremos las dos formas. Además de que en la versión 2005 de Visual C#, el propio editor nos permite crear automáticamente el método que recibirá la notificación de que el evento se ha producido.

Ligar un método de evento en Visual Basic usando WithEvents y Handles

En Visual Basic, la forma más fácil de usar las variables que definen eventos es declarándola con WithEvents, de esa forma podemos usar la instrucción Handles para ligar el método con el evento, además de que podemos usar el propio editor de Visual Basic para crear automáticamente el método que recibirá la notificación de que el evento se ha producido.

En el siguiente código tenemos la definición de la clase usando WithEvents y la definición del método usando la cláusula Handles seguida de la variable y el evento que queremos asociar con ese método:

' De esta forma podemos definir el método usando Handles
WithEvents prueba As New MiClase1

' Si la variable está definida con WithEvents
' podemos usar Handles para ligar el método con el evento
Private Sub prueba_MiEvento( _
            ByVal param1 As String, ByVal param2 As Integer) _
            Handles prueba.MiEvento

    Console.WriteLine( _
        "Se produce el evento MiEvento con los parámetros: {0} y {1}", param1, param2)
End Sub

Nota:
La cláusula Handles solo la podemos usar con variables definidas con WithEvents.

Ligar un método de evento en Visual Basic usando AddHandler

La otra forma de ligar un método de evento en Visual Basic es definiendo la variable de forma normal (sin WithEvents) y asociando ese método con el evento por medio de AddHanlder.
En este caso, siempre que volvamos a crear una instancia de la clase debemos volver a ligar el método con el evento, algo que no es necesario hacer si lo hemos definido con WithEvents y Handles.

En el siguiente código vemos cómo usar la instrucción AddHandler, en el primer parámetro indicamos la variable y el evento que queremos interceptar y en el segundo debemos indicar el método que recibirá la notificación, en ese segundo parámetro siempre debemos usar AddressOf antes del nombre del método.

Sub UsarMiClase1()
    ' Definiendo la clase de esta forma
    Dim prueba As New MiClase1
    ' tenemos que ligar el evento con AddHandler
    AddHandler prueba.MiEvento, AddressOf prueba_MiEvento

    prueba.Mostrar("Guille", 49)

End Sub

Private Sub prueba_MiEvento( _
            ByVal param1 As String, ByVal param2 As Integer)

    Console.WriteLine( _
        "Se produce el evento MiEvento con los parámetros: {0} y {1}", param1, param2)
End Sub

Nota:
La única forma que tiene el editor de Visual Basic de generar automáticamente el método que recibirá el evento es si la variable está definida con WithEvents, estando en la ventana de código, elegimos esa variable de la lista desplegable de la izquierda, al hacer esto, en la lista desplegable de la derecha se mostrarán los eventos que dicha clase defina. Y al elegir el evento se añadirá el código correcto y tambén la cláusula Handles correspondiente.

Ligar un método de evento en C#

En C# podemos ligar un método de evento con el evento adecuado usando el operador +=.

Dependiendo de que estemos usando la versión 2.0 (o superior) de C# u otra anterior, la forma de indicar el método que recibirá el evento se simplifica.

En la forma "larga" (válida para cualquier versión de C#), después del operador += debemos indicar un constructor con el tipo de delegado adecuado al que le pasaremos el método que queramos usar para interceptar dicho evento.

En la versión "corta" (válida para C# 2.0 -Visual C# 2005- o superior) no es necesario indicar el delegado, solo el nombre del método.

En cualquier caso, el método debe tener la misma firma que el delegado, es decir, debe ser del mismo tipo (normalmente void) y debe tener los mismos parámetros.

Si estamos usando Visual C# 2005 (o superior) el propio editor nos permite crear automáticamente dicho método.

Veamos las dos formas de ligar el evento con el método:

Usando la versión larga, válida para cualquier versión de C#

public static void UsarMiClase1()
{
    MiClase1 prueba = new MiClase1();
    prueba.MiEvento += new MiEventoEventHandler(prueba_MiEvento);

    prueba.Mostrar("Guille", 49);
}

static private void prueba_MiEvento(string param1, int param2)
{
    Console.WriteLine( 
        "Se produce el evento MiEvento con los parámetros: {0} y {1}", param1, param2);
}

Usando la versión corta, válida para C# 2.0 (2005) o superior

public static void UsarMiClase1()
{
    MiClase1 prueba = new MiClase1();
    // En C# 2.0 o superior no es necesario usar el delegado
    // para ligar el método con el evento
    prueba.MiEvento += prueba_MiEvento;

    prueba.Mostrar("el Guille", 49);
}

static private void prueba_MiEvento(string param1, int param2)
{
    Console.WriteLine(
        "Se produce el evento MiEvento con los parámetros: {0} y {1}", param1, param2);
}

Recordarte que el primer ejemplo será válido para cualquier versión de C#, mientras que el segundo solo será válido para C# 2.0 o superior, y recordarte también que C# 2.0 es lo mismo que Visual C# 2005.

Desligar un método de un evento

Si queremos desligar un método de un evento (para que ese evento ya no se siga interceptando), podemos hacerlo de la siguiente forma:

En C# usaremos el operador -= de la misma forma que usamos el operador +=, pero en este caso, lo que hace es que el método que esté después de ese operador se desligue del evento.

En Visual Basic usaremos la instrucción RemoveHandler, esta instrucción se usa de la misma forma que AddHandler, es decir, primero indicamos el evento que queremos desligar y después indicaremos el método que queremos que ya no se use para recibir dicho evento, como bien supones, el método debe ir precedido de la instrucción AddressOf.

Nota:
En Visual Basic siempre se usará RemoveHandler aunque el evento lo hayamos ligado con WithEvents y Handles.