CodeGym /Cursos /C# SELF /Suscriptores y llamada segura a eventos

Suscriptores y llamada segura a eventos

C# SELF
Nivel 53, Lección 2
Disponible

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.

2
Tarea
C# SELF, nivel 53, lección 2
Bloqueada
Llamada segura de eventos con manejo de excepciones
Llamada segura de eventos con manejo de excepciones
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION