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.
GO TO FULL VERSION