CodeGym /Cursos /C# SELF /Patrón «Publicador-Suscriptor» y eventos en C# ( event)

Patrón «Publicador-Suscriptor» y eventos en C# ( event)

C# SELF
Nivel 52, Lección 0
Disponible

1. Introducción

Al trabajar con programas, inevitablemente te encuentras con situaciones donde una parte debe «notificar» a otras que ocurrió algo importante. El ejemplo clásico: el usuario hizo clic con el ratón y ese evento necesita ser procesado. En la vida diaria ya vivimos en un mundo de eventos: la tetera empezó a silbar en la cocina — escuchaste la señal y fuiste a apagar la placa. El café se derramó sobre el teclado — el corazón dio un vuelco — y salvaste el portátil. La programación sigue las mismas reglas.

Evento — es un mecanismo que permite a un objeto-fuente (publicador) avisar a otros objetos (suscriptores) sobre cambios o acciones ocurridas. Es una especie de «yo avisé — quien prestó atención, respondió».

En C# los eventos son una construcción especial basada en un tipo delegado. El delegado define la firma del callback — qué y cómo será llamado en los suscriptores. La declaración de un evento se hace con la palabra clave event, y el delegado — con la palabra clave delegate.

¿Para qué sirven los eventos?

  • Desacoplamiento: El publicador no sabe nada de los suscriptores — solo emite la señal.
  • Flexibilidad de arquitectura: Puedes añadir y quitar handlers dinámicamente sin cambiar el código del publicador.
  • Escalabilidad: Añadiste un nuevo suscriptor — y de inmediato empieza a recibir notificaciones.

Patrón clásico «Publicador-Suscriptor»

Imagina que tenemos la clase «Alarma contra incendios» (publicador) y la clase «Persona en el edificio» (suscriptor). Cuando suena la alarma, manda la señal a todos al mismo tiempo — no importa cuántas personas están en el edificio ni dónde exactamente. Esto es el patrón «Publicador-Suscriptor» (o Observer).

El publicador no sabe cuántos ni qué suscriptores hay — simplemente notifica, y los demás se suscriben a las notificaciones o las ignoran.

¿Cómo funciona esto en C#?

  • Publicador: define el evento (event), proporciona suscripción/cancelación de suscripción.
  • Suscriptor: se suscribe al evento y implementa el handler (el método-handler será llamado cuando ocurra el evento).

2. Eventos en la práctica: primer ejemplo

Pasando de la casa al código, describamos un modelo simple. Supongamos que tenemos una aplicación de consola donde un objeto-timer hace «tic» cada segundo, y varios handlers reaccionan (por ejemplo, imprimen «tic» en la consola o cuentan el número de tics).

Paso 1. Definir el delegado y el evento


public class SimpleTimer
{
    // Declaramos el delegado para el evento
    public delegate void TickEventHandler(object sender, EventArgs e);

    // Evento basado en el delegado
    public event TickEventHandler Tick;

    public void Start(int count)
    {
        for (int i = 0; i < count; i++)
        {
            System.Threading.Thread.Sleep(1000); // ¡imitación de tic!
            OnTick(); // ¡despachar el evento!
        }
    }

    protected virtual void OnTick()
    {
        // Llamamos al evento si hay suscriptores (Tick != null)
        Tick?.Invoke(this, EventArgs.Empty);
    }
}

¿Qué pasa aquí?

  • Se define el delegado TickEventHandler con la firma clásica object sender, EventArgs e.
  • El evento Tick — punto de suscripción para los handlers.
  • El método Start simula el «tiqueo» y llama periodicamente a OnTick.
  • En OnTick el evento se invoca de forma segura: Tick?.Invoke(..., EventArgs.Empty).

Paso 2. Suscribirse al evento


class Program
{
    static void Main()
    {
        var timer = new SimpleTimer();

        // Nos suscribimos al evento Tick
        timer.Tick += Timer_Tick;

        timer.Start(3);

        // Se puede desuscribir, si hace falta
        timer.Tick -= Timer_Tick;
    }

    static void Timer_Tick(object sender, EventArgs e)
    {
        Console.WriteLine("¡Tic!");
    }
}

Creamos el timer, nos suscribimos con el operador +=, luego en cada tic se llama al handler. La cancelación de suscripción usa el operador -=.

3. Matices útiles

¿Por qué los eventos son mejores que llamadas rígidas?

Si SimpleTimer en OnTick escribiera directamente en la consola, la clase estaría fuertemente acoplada a esa acción concreta. Los eventos «liberan» el código: el timer no sabe qué harán los suscriptores — lanzar un cohete, loguear a un fichero o enviar un e-mail.

Diferencia importante entre eventos y delegados

  • Delegado — un «puntero» a un método, y evento — es un delegado con restricciones de acceso.
  • Los suscriptores solo pueden suscribirse/desuscribirse; invocar el evento desde afuera no es posible — solo el publicador puede hacerlo.
  • Para declarar un evento, añade el modificador event al tipo delegado — el compilador garantizará el modelo de acceso correcto.

Esquema breve de cómo funciona un evento en C#


+------------------+          +------------------------------+
|                  |          |                              |
|    Publicador    | <------> |         Suscriptor           |
| (Publisher/Event)|          |      (Subscriber/Handler)    |
|                  |          |                              |
+------------------+          +------------------------------+
         | 1) declara el evento       | 2) se suscribe al evento
         | 3) lo invoca               | 4) implementa el handler

¿Cuándo usar eventos?

  • Necesitas notificar a un número indefinido de listeners sobre algo ocurrido.
  • No quieres acoplar la lógica de acciones dentro de la clase-fuente.
  • UI, interacción asíncrona, notificaciones del sistema — todo gira alrededor de eventos.

Características breves de la implementación de eventos en C#

  • No se puede invocar un evento «desde fuera»: solo el código del publicador tiene derecho a Invoke.
  • Suscripción/cancelación: operadores +=/-=; puede haber varios handlers.
  • Un evento es básicamente una lista de delegados: cuando ocurre, se llaman todos los handlers en el orden de suscripción.
  • Delegados recomendados: usa EventHandler y EventHandler<TEventArgs> para compatibilidad con el ecosistema .NET.

4. Errores típicos de principiantes

Olvidar comprobar que hay suscriptores: Tick != null. Mejor usar la llamada segura: Tick?.Invoke(...).

Se suscriben a un evento pero no se desuscriben cuando el handler ya no es necesario. Esto puede mantener objetos en memoria y provocar fugas.

Intentar «invocar» el evento desde una clase externa — el compilador no lo permitirá. No puedes escribir algo como game.GameOver() si eso es un evento y no un método.

No respetar la firma del delegado. Para eventos usa los estándar EventHandler o EventHandler<TEventArgs> — así el código será compatible con otras librerías .NET.

2
Tarea
C# SELF, nivel 52, lección 0
Bloqueada
Creación de un evento y un suscriptor
Creación de un evento y un suscriptor
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION