CodeGym /Cursos /C# SELF /Manejo de eventos: expresiones lambda

Manejo de eventos: expresiones lambda

C# SELF
Nivel 52, Lección 4
Disponible

1. Introducción

En muchos proyectos modernos en C# casi no se usan métodos "normales" para manejar eventos. Ha ocurrido así porque las expresiones lambda permiten declarar rápidamente y de forma concisa un manejador justo en el lugar de la suscripción (operador +=), si el manejo es simple y no se reutiliza en otras partes del código. Es parecido a pegar una nota pequeña directamente en la cafetera con la instrucción «pulsa este botón» en vez de escribir un manual detallado y guardarlo en una carpeta separada. Si la tarea es local y única, ¡la lambda es ideal!

Dónde se usa en la práctica

  • En ASP.NET (por ejemplo, al manejar eventos del ciclo de vida de la página),
  • En WPF/WinForms para UI (por ejemplo, al hacer clic en un botón),
  • En programación de servidor (por ejemplo, lógica dentro del pipeline),
  • En tests, cuando el manejador no necesita un nombre separado.

Sintaxis: cómo se ve en código

Empecemos viendo el manejo habitual de un evento:


// Declaración del evento
public event EventHandler? MyEvent;

// Suscripción al evento con un método normal
void Handler(object? sender, EventArgs e)
{
    Console.WriteLine("¡El evento ocurrió!");
}

public void Subscribe()
{
    MyEvent += Handler;
}

Ahora — la variante con una expresión lambda (función anónima):


public void Subscribe()
{
    MyEvent += (sender, e) => Console.WriteLine("¡El evento ocurrió (lambda)!");
}

Fíjate: no creamos un método separado, sino que asignamos el manejador directamente al suscribirnos al evento. La firma de la lambda coincide automáticamente con el tipo del evento (EventHandler).

Comparación de enfoques

Método normal Lambda
Volumen de código Más (método + suscripción) Menos, todo en el mismo sitio
Reutilizabilidad Se puede reutilizar Normalmente no
Localidad del código Distribuido Todo junto
Claridad/legibilidad Bueno para lógica compleja Ideal para casos simples

2. Aplicación con manejo de eventos y lambdas

Estructura básica


public class Menu
{
    public event EventHandler? ItemSelected;

    public void SelectItem(int index)
    {
        Console.WriteLine($"Elemento del menú {index} seleccionado.");
        ItemSelected?.Invoke(this, EventArgs.Empty);
    }
}

Suscripción con una expresión lambda


class Program
{
    static void Main()
    {
        var menu = new Menu();

        // Suscripción al evento mediante una lambda
        menu.ItemSelected += (sender, e) =>
        {
            Console.WriteLine("¡Gracias por tu elección! El manejador lambda se ejecutó.");
        };

        menu.SelectItem(1);
    }
}

Salida esperada:

Elemento del menú 1 seleccionado.
¡Gracias por tu elección! El manejador lambda se ejecutó.

Captura de variables desde el contexto externo

Una de las ventajas de la expresión lambda es que puede "recordar" valores del scope externo (ámbito de visibilidad). Por ejemplo, contar cuántas veces se ha seleccionado un elemento del menú: la variable counter será capturada por el closure.


static void Main()
{
    var menu = new Menu();
    int counter = 0;

    menu.ItemSelected += (s, e) =>
    {
        counter++;
        Console.WriteLine($"¡Elemento seleccionado {counter} vez(ces)!");
    };

    menu.SelectItem(1);
    menu.SelectItem(2);
}

Salida esperada:

Elemento del menú 1 seleccionado.
¡Elemento seleccionado 1 vez(ces)!
Elemento del menú 2 seleccionado.
¡Elemento seleccionado 2 vez(ces)!

Esta es la magia de los closures en acción: la variable counter sigue viva dentro de la lambda.

Ejemplo con parámetros del evento

Si tu evento usa EventHandler<T>, donde T es una clase propia con información adicional, la expresión lambda simplemente se "adapta" a la firma necesaria.


public class MenuItemSelectedEventArgs : EventArgs
{
    public int ItemIndex { get; }
    public string Description { get; }

    public MenuItemSelectedEventArgs(int itemIndex, string description)
    {
        ItemIndex = itemIndex;
        Description = description;
    }
}

public class Menu
{
    public event EventHandler<MenuItemSelectedEventArgs>? ItemSelected;

    public void SelectItem(int index, string description)
    {
        Console.WriteLine($"Elemento del menú {index}: {description} seleccionado.");
        ItemSelected?.Invoke(this, new MenuItemSelectedEventArgs(index, description));
    }
}

// Uso
static void Main()
{
    var menu = new Menu();

    // Lambda desempaquetando los argumentos del evento
    menu.ItemSelected += (sender, args) =>
    {
        Console.WriteLine($"Seleccionado el elemento #{args.ItemIndex}: {args.Description.ToUpper()}");
    };

    menu.SelectItem(3, "Sobre el programa");
}

Salida esperada:

Elemento del menú 3: Sobre el programa seleccionado.
Seleccionado el elemento #3: SOBRE EL PROGRAMA

3. Manejadores locales y lambda

Las lambdas son ideales cuando:

  • La lógica de manejo es corta y clara,
  • El manejador se usa sólo en un lugar,
  • Necesitas "cerrar" variables desde el contexto local.

Si el manejo es complejo, requiere reutilización o puede ser invocado fuera del lugar de declaración, es mejor usar un método nombrado.

Ejemplo: con lógica dentro y fuera

Lambda (ideal):


button.Click += (s, e) => MessageBox.Show("¡Botón pulsado!");

Métodos (cuando la lógica es más compleja o se necesita reutilizar):


button.Click += Button_Click;

void Button_Click(object sender, EventArgs e)
{
    if (UserConfirmed())
    {
        SaveData();
        MessageBox.Show("¡Datos guardados!");
    }
}

4. Bajo el capó: qué pasa con los manejadores lambda

Una lambda también es un delegate, igual que un manejador normal. El compilador crea "en tiempo de compilación" un método anónimo, y si captura variables, también una clase oculta para almacenarlas.

Es importante recordar (y es un error frecuente): si creas una lambda dentro de un bucle y la suscribes a un evento, todas las iteraciones pueden capturar la misma variable de bucle.


for (int i = 0; i < 5; i++)
{
    buttons[i].Click += (sender, e) =>
    {
        Console.WriteLine($"Clic en el botón #{i}");
    };
}

Para todos los manejadores el número del botón podría resultar ser 5. Para evitarlo, crea una copia de la variable dentro del bucle:


for (int i = 0; i < 5; i++)
{
    int buttonIndex = i; // copia local
    buttons[i].Click += (sender, e) =>
    {
        Console.WriteLine($"Clic en el botón #{buttonIndex}");
    };
}

Ahora todo funciona como se espera.

Todo el poder de los manejadores lambda: en la vida real

Esas expresiones lambda ahorran tiempo y aceleran el desarrollo, especialmente cuando la lógica es simple. Hacen que el código esté "más cerca de la tarea", sin dispersarlo por archivos y clases. En proyectos reales las verás por todas partes: desde manejo de eventos en UI hasta suscripciones a mensajes en buses de eventos asíncronos.

5. Errores típicos

Error nº1: olvidar desuscribirse (-=) en objetos de larga vida.
Si el objeto suscriptor no se desuscribe del evento del publicador, la referencia del delegate mantiene al suscriptor en memoria — el garbage collector no podrá recogerlo, aunque no haya otras referencias al objeto. Como resultado aparecen "fugas" de memoria y dependencias colgando, especialmente cuando el publicador vive mucho (eventos estáticos, singletons, servicios).
Cómo evitarlo: siempre desuscríbete en la limpieza/destrucción (por ejemplo, Dispose, OnDisable, OnDestroy). Considera weak references (weak events / WeakEventManager), usar un patrón de "event manager" o IObservable/Rx si el escenario es complejo.

Error nº2: capturar variables del bucle sin copia local.
La trampa típica es escribir la suscripción dentro de un bucle y que el closure capture la misma variable de bucle, así todos los manejadores ven su valor final en vez del valor que había al crear cada manejador. Esto provoca resultados inesperados (todos los manejadores "imprimen" el mismo número, etc.).
Cómo evitarlo: crea una copia local dentro del bucle y captura esa copia:


for (int i = 0; i < n; i++)
{
    int current = i;
    button.Click += (s, e) => Handle(current);
}

O pasa el valor necesario a un método wrapper. Es más fiable y deja la intención clara.

Error nº3: usar lambdas enormes en el sitio de la suscripción.
Si pones lógica de negocio pesada directamente en la función anónima al suscribirte, el código se vuelve difícil de leer, probar y depurar. Además — con lambdas anónimas es más complicado desuscribirse correctamente porque necesitas exactamente la misma instancia del delegate. Como resultado la lógica se dispersa y pierde estructura.
Cómo evitarlo: extrae la lógica compleja a métodos nombrados o servicios; si hace falta, guarda el delegate en una variable/campo para poder desuscribirte; deja en la lambda solo un pequeño wrapper/redirección. Esto mejora la legibilidad y la mantenibilidad del código.

2
Tarea
C# SELF, nivel 52, lección 4
Bloqueada
Botón con datos personalizados
Botón con datos personalizados
1
Cuestionario/control
Eventos en C#, nivel 52, lección 4
No disponible
Eventos en C#
Creación de eventos usando delegados
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION