Eventos en C#

En el desarrollo de software, la comunicación entre objetos es fundamental para crear aplicaciones robustas y escalables. Los eventos en C# proporcionan un mecanismo poderoso para lograr esta comunicación, permitiendo que los objetos se notifiquen entre sí cuando ocurren cambios o acciones específicas.

¿Qué son los eventos?

Un evento es un mecanismo que permite a un objeto notificar a otros objetos que ha ocurrido un cambio o una acción específica. En C#, los eventos se implementan mediante delegados, que son tipos especiales que encapsulan una lista de métodos.

¿Cómo funcionan los eventos?

  1. Declaración del evento: Se define un delegado que representa el tipo de evento.
  2. Publicación del evento: La clase que genera el evento (publicador) declara una variable de tipo delegado para el evento.
  3. Suscripción al evento: Las clases que desean recibir notificaciones del evento (suscriptores) se suscriben al evento mediante el operador +=.
  4. Generación del evento: Cuando ocurre el evento, el publicador invoca el delegado, lo que a su vez ejecuta los métodos de los suscriptores.

Ejemplo:

Supongamos que tenemos una clase Button que genera un evento Click cuando se hace clic en el botón.

En la clase Button:


public delegate void ClickEventHandler(object sender, EventArgs e);

public event ClickEventHandler Click;

protected virtual void OnClick(EventArgs e)
{
    Click?.Invoke(this, e);
}

Lenguaje del código: C# (cs)

Declaración de Eventos

Para declarar un evento en C#, primero necesitas definir un delegado que represente el tipo de método que se invocará cuando se produzca el evento. Luego, puedes declarar un evento utilizando ese delegado. Aquí tienes la sintaxis básica para declarar un evento:


public delegate void NombreDelegado(tipoParametro1 parametro1, tipoParametro2 parametro2, ...);

public event NombreDelegado NombreEvento;

Lenguaje del código: C# (cs)

Ejemplo de Uso de Eventos

Para entender mejor cómo funcionan los eventos en C#, veamos un ejemplo simple. Supongamos que queremos crear una clase Reloj que genere un evento cada vez que transcurra un segundo.

Otros objetos de la aplicación pueden suscribirse a este evento para realizar acciones específicas cuando ocurra un cambio en el tiempo. Aquí tienes el código de ejemplo:


using System;
using System.Threading;

// Declaración del delegado para el evento
public delegate void SegundoTranscurridoEventHandler(object sender, EventArgs e);

public class Reloj
{
    // Declaración del evento
    public event SegundoTranscurridoEventHandler SegundoTranscurrido;

    // Método para iniciar el reloj y generar eventos cada segundo
    public void Iniciar()
    {
        while (true)
        {
            Thread.Sleep(1000); // Esperar un segundo
            OnSegundoTranscurrido(); // Generar evento
        }
    }

    // Método para invocar el evento
    protected virtual void OnSegundoTranscurrido()
    {
        SegundoTranscurrido?.Invoke(this, EventArgs.Empty);
    }
}

// Clase que se suscribe al evento del reloj
public class Observador
{
    // Constructor
    public Observador(Reloj reloj)
    {
        reloj.SegundoTranscurrido += Reloj_SegundoTranscurrido;
    }

    // Método que se ejecuta cuando ocurre el evento
    private void Reloj_SegundoTranscurrido(object sender, EventArgs e)
    {
        Console.WriteLine("¡Ha transcurrido un segundo!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Reloj reloj = new Reloj();
        Observador observador = new Observador(reloj);

        // Iniciar el reloj
        reloj.Iniciar();
    }
}

Lenguaje del código: C# (cs)

En este ejemplo, creamos una clase Reloj que genera un evento SegundoTranscurrido cada segundo. Luego, creamos una clase Observador que se suscribe a este evento y realiza alguna acción cuando ocurre.

Finalmente, en el método Main, creamos una instancia del reloj y del observador, y luego iniciamos el reloj.