1. Introducción
Cuando escribimos
worker.WorkCompleted += listener.OnWorkCompleted;
en realidad estamos añadiendo un puntero a un método en la "invocation list" (multicast delegate) del evento. Esa "lista" dentro del evento es simplemente una secuencia de métodos que serán llamados cuando se dispare el evento. En C# el evento está implementado sobre un delegate que soporta múltiples suscriptores.
Imagina un boletín: tienes una lista de suscriptores (direcciones email). Cuando envías el boletín (invocas el evento), todos los suscriptores reciben el mensaje. Si alguien se da de baja, lo quitas de la lista y deja de recibir correos.
Cómo añadir o quitar un suscriptor
La suscripción (+=) y la desuscripción (-=) operan sobre el delegate dentro del evento. Aquí tienes un ejemplo con una lambda que puedes subscribir y luego desubscribir:
EventHandler<WorkCompletedEventArgs> handler = (sender, e) =>
{
Console.WriteLine($"[Lambda] Trabajo completado: {e.Message}");
};
worker.WorkCompleted += handler; // Nos subscribimos
worker.WorkCompleted -= handler; // Nos desubscribimos
En el caso de métodos normales la desuscripción es igual:
worker.WorkCompleted += listener.OnWorkCompleted;
worker.WorkCompleted -= listener.OnWorkCompleted;
Ten en cuenta: si te suscribiste al mismo método varias veces, se llamará tantas veces y para desuscribirte necesitas ejecutar -= la misma cantidad de veces.
2. ¿Por qué gestionar manualmente?
¿Por qué es importante gestionar suscriptores?
En aplicaciones reales, especialmente las de larga vida (por ejemplo, de escritorio o servidores), una gestión incorrecta de las suscripciones puede llevar a memory leaks. Si un objeto-suscriptor ya no es necesario pero todavía "cuelga" en la invocation list, el garbage collector no lo liberará — porque todavía existe una referencia desde el delegate del evento.
Ilustración
| Acción | Resultado para el suscriptor |
|---|---|
| += (nos subscribimos) | Se añade a la lista |
| -= (nos desubscribimos) | Se elimina de la lista |
| Objeto suscriptor eliminado | Si NO está desubscrito! — NO se elimina, porque todavía hay una referencia en el evento |
| Objeto suscriptor eliminado | Si ESTÁ desubscrito — se libera con normalidad |
¿Cómo saber quién está suscrito a un evento?
Los eventos encapsulan la lista de suscriptores, así que desde fuera del class-publisher no puedes obtener esa lista directamente — solo puedes añadir (+=) o quitar (-=) manejadores.
Sin embargo, dentro de la clase donde se declara el evento basado en un delegate (por ejemplo, EventHandler), puedes obtener la lista actual de suscriptores usando GetInvocationList():
// Dentro de la clase-publisher
if (WorkCompleted != null)
{
foreach (Delegate subscriber in WorkCompleted.GetInvocationList())
{
Console.WriteLine($"Manejador: {subscriber.Method.Name}, Objeto: {subscriber.Target}");
}
}
Ese truco rara vez es necesario en desarrollo diario, pero puede ser útil para debugging o para implementar métodos de desuscripción masiva de todos los suscriptores.
3. Llamada segura a eventos: "minas" y cómo evitarlas
¿Qué puede salir mal al invocar un evento?
Todo parece simple: llamas
WorkCompleted?.Invoke(this, args);
y todo funciona... La mayor parte del tiempo. Pero hay matices. Aquí van:
1. Peligro multihilo
En una aplicación multihilo puede ocurrir que entre la comprobación de null y la invocación otro hilo cambie las suscripciones. Por ejemplo:
1) Hilo A comprueba: WorkCompleted != null.
2) Al mismo tiempo hilo B se desuscribe del evento (-=), y la lista de manejadores queda vacía.
3) Hilo A intenta llamar WorkCompleted.Invoke(...) — se lanza NullReferenceException, porque ya no hay manejadores.
Esta es una clásica race condition al trabajar con eventos.
2. Excepciones inesperadas en manejadores
Si uno de los suscriptores lanza una excepción durante el manejo del evento, la invocación de los demás manejadores se interrumpe. Es decir, el evento "se rompe" en la primera excepción, y los demás suscriptores no reciben la notificación. Para evitarlo, es recomendable envolver la llamada a cada manejador en un try-catch si es importante que todos reciban la señal.
3. Fuga indeseada de contexto
Un manejador suele ser un método de instancia que captura la referencia al objeto-suscriptor (this). Si el suscriptor olvida desuscribirse del publisher, la referencia al mismo se mantiene en la invocation list del publisher. Como resultado, el garbage collector no podrá liberar ese objeto — aparece un memory leak.
¿Cómo invocar un evento de forma segura?
1) Copiar el delegate a una variable local
Llamar usando una variable local garantiza que durante la invocación la lista de suscriptores no cambie:
// La forma clásica
var handler = WorkCompleted;
if (handler != null)
{
handler(this, args);
}
O más moderno, con el operador null-conditional:
WorkCompleted?.Invoke(this, args);
En la mayoría de los casos esto es suficiente, porque el compilador de C# suele "entender" esta construcción y hace la copia interna de la referencia (ver documentación oficial).
2) Protecciones contra excepciones en los manejadores
Si es crítico que todos los manejadores se ejecuten (incluso si alguno falla), usa la iteración manual:
var handler = WorkCompleted;
if (handler != null)
{
foreach (EventHandler<WorkCompletedEventArgs> subscriber in handler.GetInvocationList())
{
try
{
subscriber(this, args);
}
catch (Exception ex)
{
// Logueamos, pero no dejamos que el evento "se desplome" por completo
Console.WriteLine($"Error en el manejador: {ex.Message}");
}
}
}
Este enfoque rara vez es necesario para escenarios UI comunes, pero es útil en librerías, loggers y sistemas complejos.
3) Prevención de memory leaks
Si el suscriptor "vive" menos que el publisher (por ejemplo, una ventana que se suscribe a un evento de la aplicación), tiene la obligación de desuscribirse:
worker.WorkCompleted -= listener.OnWorkCompleted;
Si no lo hace, el garbage collector no podrá liberar a listener, aunque no haya otras referencias "visibles" a él.
4. Ejemplo práctico: gestor de suscripciones y desuscripciones masivas
Extendamos nuestra app de ejemplo. Imagina que tenemos varios listeners — y queremos suscribirlos y desuscribirlos dinámicamente durante la ejecución.
public class WorkListener
{
private readonly string _name;
public WorkListener(string name)
{
_name = name;
}
public void OnWorkCompleted(object sender, WorkCompletedEventArgs e)
{
Console.WriteLine($"Listener {_name}: {e.Message}");
}
}
En el programa principal:
var worker = new Worker();
var listeners = new List<WorkListener>
{
new WorkListener("Ivan"),
new WorkListener("Maria"),
new WorkListener("Denis")
};
// Suscribimos a todos los listeners
foreach (var listener in listeners)
worker.WorkCompleted += listener.OnWorkCompleted;
// Disparamos el evento
worker.DoWork();
// Desuscripción masiva
foreach (var listener in listeners)
worker.WorkCompleted -= listener.OnWorkCompleted;
// Comprobamos que nadie responde
worker.DoWork();
En la consola, después del primer DoWork aparecerán 3 mensajes, después del segundo — ninguno.
5. Consejos para trabajar seguro con eventos
- Desuscríbete a tiempo si el ciclo de vida del suscriptor es menor que el del publisher.
- Si implementas el patrón "publisher de larga vida — subscriber temporal", siempre desuscribe, por ejemplo en Dispose(), al cerrar una ventana o al terminar explícitamente la vida del objeto.
- Para eventos one-shot puedes usar un manejador anónimo (lambda) que se desuscriba a sí mismo desde dentro:
EventHandler<WorkCompletedEventArgs> handler = null;
handler = (s, e) =>
{
Console.WriteLine("¡Evento manejado una vez!");
worker.WorkCompleted -= handler;
};
worker.WorkCompleted += handler;
- No guardes referencias a suscriptores o manejadores solo para comprobar "quién está suscrito" — no suele ser necesario en lógica de negocio normal. Hazlo solo para debugging.
6. Errores comunes y cómo evitarlos
Error №1: olvidarse de desuscribirse — memory leak.
Si un suscriptor no se desuscribe, especialmente en aplicaciones grandes con muchos eventos y suscriptores, los objetos pueden quedarse en memoria más tiempo del necesario. Este error a menudo tarda en mostrarse, pero conduce a aumento de consumo de memoria y degradación del rendimiento.
Error №2: invocar el evento sin comprobar null.
Si un evento no tiene suscriptores y intentas invocarlo directamente, obtendrás un NullReferenceException. En versiones nuevas de C# ayuda el operador seguro ?., pero si trabajas con código antiguo o iteras manejadores manualmente, no olvides comprobar null.
Error №3: excepción en uno de los manejadores interrumpe a los demás.
Si un manejador lanza una excepción, los manejadores siguientes no serán ejecutados. Si es importante que todos los suscriptores reciban la notificación, itera sobre los manejadores y envuelve cada llamada en un bloque try/catch.
GO TO FULL VERSION