C# Academy · Lección

Notificaciones y eventos

Publique eventos de dominio con MediatR.

Notificaciones y eventos es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Solicitudes frente a notificaciones

Una solicitud tiene un handler y devuelve un valor. Una notificación es una difusión: tiene cero o más handlers y no devuelve nada. Utilice las notificaciones para anunciar que algo ha ocurrido.

// Request:      one handler, returns a result
// Notification: many handlers, fire-and-forget

INotification

Un evento de dominio es un registro que implementa INotification. Describe un hecho ya ocurrido.

public record OrderPlacedNotification(int OrderId, int CustomerId)
    : INotification;

INotificationHandler

Cada suscriptor implementa INotificationHandler<TNotification>. Muchos controladores pueden suscribirse a la misma notificación y cada uno la procesa de forma independiente.

public class SendConfirmationEmailHandler
    : INotificationHandler<OrderPlacedNotification>
{
    public Task Handle(
        OrderPlacedNotification n, CancellationToken ct)
    {
        // send the email...
        return Task.CompletedTask;
    }
}

Varios suscriptores

Añada tantos controladores como necesite. Ninguno conoce a los demás; puede añadir nuevas reacciones sin modificar el publicador.

public class UpdateInventoryHandler
    : INotificationHandler<OrderPlacedNotification>
{
    public Task Handle(OrderPlacedNotification n, CancellationToken ct)
    {
        // decrement stock...
        return Task.CompletedTask;
    }
}

Publicación

Para generar una notificación, inyecte IPublisher (o IMediator) y llame a Publish. Se invoca a todos los controladores registrados.

public class CreateOrderHandler(AppDbContext db, IPublisher publisher)
    : IRequestHandler<CreateOrderCommand, int>
{
    public async Task<int> Handle(CreateOrderCommand c, CancellationToken ct)
    {
        var order = new Order { CustomerId = c.CustomerId };
        db.Orders.Add(order);
        await db.SaveChangesAsync(ct);
        await publisher.Publish(
            new OrderPlacedNotification(order.Id, c.CustomerId), ct);
        return order.Id;
    }
}

Desacoplamiento de efectos secundarios

Las notificaciones mantienen centrado el caso de uso principal. Al realizar un pedido, solo se registra el pedido y se publica un evento; el envío de correos y la gestión del inventario residen en sus propios controladores. Este es el principio de abierto/cerrado en acción.

// CreateOrderHandler does NOT know about email or inventory

Estrategia de publicación

De forma predeterminada, MediatR espera a cada controlador de notificaciones secuencialmente. Si uno produce una excepción, los controladores posteriores no se ejecutan. Puede proporcionar un publicador personalizado para ejecutarlos en paralelo.

builder.Services.AddMediatR(cfg =>
{
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly);
    cfg.NotificationPublisher = new TaskWhenAllPublisher();
});

Gestión de errores

Como los controladores son independientes, debe decidir qué significa un error. Para efectos secundarios no críticos, capture y registre la excepción dentro del controlador para que un error no interrumpa a los demás.

public async Task Handle(OrderPlacedNotification n, CancellationToken ct)
{
    try { await _email.SendAsync(n.CustomerId, ct); }
    catch (Exception ex) { _logger.LogError(ex, "email failed"); }
}

Patrón de eventos de dominio

Un patrón habitual consiste en que las entidades recopilen eventos de dominio y, después de guardar la transacción, se publiquen todos. Esto garantiza que los eventos solo se produzcan cuando el cambio se haya confirmado.

await db.SaveChangesAsync(ct);
foreach (var domainEvent in order.Events)
    await publisher.Publish(domainEvent, ct);
order.Events.Clear();

Notificaciones frente a colas de mensajes

Las notificaciones de MediatR son en proceso y síncronas dentro de la solicitud. Para una entrega entre servicios o duradera, publique en su lugar en un broker de mensajes real (por ejemplo, RabbitMQ o Azure Service Bus).

// In-process reactions  -> MediatR notifications
// Cross-service / durable -> message broker

Pruebas de notificaciones

Puede comprobar que un controlador publica el evento correcto pasando un mock de IPublisher y verificando que se llamó.

var publisher = new Mock<IPublisher>();
var handler = new CreateOrderHandler(db, publisher.Object);
await handler.Handle(new CreateOrderCommand(1, []), default);
publisher.Verify(p => p.Publish(
    It.IsAny<OrderPlacedNotification>(), default), Times.Once);

Comprobación rápida

Confirme el modelo de notificaciones.

Resumen

Ha aprendido sobre las notificaciones y los eventos:

INotification es una difusión con cero o más INotificationHandler.
Publique con IPublisher.Publish para invocar a todos los suscriptores.
Las notificaciones desacoplan los efectos secundarios y siguen el principio de abierto/cerrado.
Se ejecutan en proceso; use un broker para eventos entre servicios o duraderos.

Con esto finaliza el curso de CQRS y MediatR.

Preguntas frecuentes

¿La lección «Notificaciones y eventos» es gratis?

Sí — el texto completo de «Notificaciones y eventos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Notificaciones y eventos»?

Publique eventos de dominio con MediatR. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Notificaciones y eventos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy