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