Delegados y Eventos en C#

En C#, los delegados y los eventos son la base de la programación dirigida por eventos. Un delegate es un tipo seguro que puede hacer referencia a un método. Un event permite que una clase notifique al mundo exterior que “una determinada acción ha ocurrido”. Estos mecanismos permiten construir arquitecturas débilmente acopladas y ejecutar métodos de manera dinámica.

¿Qué es un Delegado?

Un delegado mantiene referencias a métodos con una firma específica (parámetros y tipo de retorno). En otras palabras, son “estructuras que pueden transportar métodos como si fueran variables”. Una sola variable de delegado puede referenciar varios métodos y llamarlos cuando sea necesario.

// Definición de un delegado
public delegate void Notify(string message);

class Program
{
    static void SendEmail(string message)
    {
        Console.WriteLine("Correo enviado: " + message);
    }

    static void SendSms(string message)
    {
        Console.WriteLine("SMS enviado: " + message);
    }

    static void Main()
    {
        Notify notifyHandler;

        // Asignar un método al delegado
        notifyHandler = SendEmail;
        notifyHandler("La reunión es a las 10:00 AM.");

        // Adjuntar otro método al mismo delegado (multicast)
        notifyHandler += SendSms;
        notifyHandler("¡Nuevo producto disponible!");
    }
}

En este ejemplo, el delegado notifyHandler llama tanto al método SendEmail como a SendSms. Los delegados permiten dirigir dinámicamente los eventos a diferentes métodos.

¿Qué es un Evento?

Un evento es un mecanismo que indica que una acción ha ocurrido. Generalmente se basa en un delegado. La palabra clave event se usa para la declaración, y solo puede utilizarse externamente con += (suscribirse) o -= (cancelar suscripción). Esto asegura que el evento solo pueda dispararse dentro de la clase, y no desde el exterior.

public class Button
{
    // Definición de un evento (EventHandler es un tipo de delegado estándar)
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("¡Botón presionado!");
        // Disparar el evento
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // Suscribirse al evento
        btn.Click += (s, e) => Console.WriteLine("Evento: el botón fue presionado.");

        btn.SimulateClick();
    }
}

Aquí, la clase Button publica un evento Click. El código suscrito (expresión lambda) se ejecuta cuando el evento se dispara. Este enfoque se usa comúnmente en aplicaciones de UI como WinForms y WPF.

EventHandler y EventArgs

En C#, el delegado estándar más utilizado para eventos es EventHandler. Con EventArgs o clases derivadas de él, se puede pasar información adicional sobre el evento.

public class OrderEventArgs : EventArgs
{
    public int OrderId { get; }
    public decimal Amount { get; }

    public OrderEventArgs(int orderId, decimal amount)
    {
        OrderId = orderId;
        Amount = amount;
    }
}

public class OrderService
{
    public event EventHandler<OrderEventArgs>? OrderCreated;

    public void CreateOrder(int id, decimal amount)
    {
        Console.WriteLine($"Pedido creado (ID={id}, Monto={amount})");

        // Disparar el evento
        OrderCreated?.Invoke(this, new OrderEventArgs(id, amount));
    }
}

class Program
{
    static void Main()
    {
        var service = new OrderService();

        service.OrderCreated += (s, e) =>
        {
            Console.WriteLine($"Notificación: Pedido recibido (#{e.OrderId}, {e.Amount} EUR)");
        };

        service.CreateOrder(101, 250m);
    }
}

En este ejemplo, la clase OrderService dispara el evento OrderCreated cada vez que se crea un nuevo pedido. El código suscrito recibe la información del pedido a través de EventArgs.

¿Cuándo usar Delegados y Eventos?

• Delegados: Para pasar métodos como parámetros, crear callbacks o invocar múltiples métodos.
• Eventos: Para anunciar interacciones del usuario (clics de botón, cierre de formularios, etc.) o cambios de estado en procesos de negocio.

TL;DR

Artículos relacionados