C# Academy · Aula

Notificações e eventos

Publique eventos de domínio com MediatR.

Notificações e eventos é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Solicitações versus notificações

Uma solicitação tem um handler e retorna um valor. Uma notificação é uma transmissão: tem zero ou mais handlers e não retorna nada. Use notificações para anunciar que algo aconteceu.

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

Notificação

Um evento de domínio é um registro que implementa INotification. Ele descreve um fato no tempo passado.

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

INotificationHandler

Cada assinante implementa INotificationHandler<TNotification>. Vários manipuladores podem assinar a mesma notificação, cada um tratando-a de forma independente.

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

Vários assinantes

Adicione quantos manipuladores forem necessários. Nenhum deles conhece os outros — novas reações podem ser adicionadas sem tocar no publisher.

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

Publicação

Para emitir uma notificação, injete IPublisher (ou IMediator) e chame Publish. Todos os manipuladores registrados são chamados.

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;
    }
}

Desacoplamento de efeitos colaterais

As notificações mantêm o caso de uso principal focado. Fazer um pedido apenas registra o pedido e publica um evento; o envio de e-mails e o controle de estoque ficam em seus próprios manipuladores. Esse é o princípio aberto/fechado em ação.

// CreateOrderHandler does NOT know about email or inventory

Estratégia de publicação

Por padrão, o MediatR aguarda cada manipulador de notificação sequencialmente. Se um deles lançar uma exceção, os manipuladores posteriores não serão executados. Você pode fornecer um publisher personalizado para executá-los em paralelo.

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

Tratamento de falhas

Como os manipuladores são independentes, determine o que uma falha significa. Para efeitos colaterais não críticos, capture e registre o erro dentro do manipulador para que uma falha não interrompa os demais.

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

Padrão de eventos de domínio

Um padrão comum é fazer com que as entidades acumulem eventos de domínio e, depois de salvar a transação, publicar todos eles. Isso garante que os eventos sejam disparados somente quando a alteração for confirmada.

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

Notificações versus filas de mensagens

As notificações do MediatR são executadas no processo e de forma síncrona durante a solicitação. Para entrega entre serviços ou persistente, publique em um agente de mensagens real (por exemplo, RabbitMQ ou Azure Service Bus).

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

Testando notificações

Você pode verificar se um manipulador publica o evento correto passando um objeto simulado de IPublisher e confirmando que ele foi chamado.

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);

Verificação rápida

Confirme o modelo de notificação.

Recapitulação

Você aprendeu sobre notificações e eventos:

INotification é uma transmissão com zero ou mais instâncias de INotificationHandler.
Publique com IPublisher.Publish para chamar todos os assinantes.
As notificações desacoplam os efeitos colaterais e seguem o princípio aberto/fechado.
Elas são executadas no processo; use um agente de mensagens para eventos entre serviços ou persistentes.

Isso conclui o curso de CQRS e MediatR.

Perguntas Frequentes

A aula “Notificações e eventos” é grátis?

Sim — o texto completo de “Notificações e eventos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Notificações e eventos”?

Publique eventos de domínio com MediatR. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Notificações e eventos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy