ASP.NET.Core - MediatR com Notificação

Neste artigo veremos como implementar notificações usando a biblioteca MediatR.

O MediatR é uma biblioteca usada em aplicativos na plataforma .NET para implementar o padrão Mediator.

O padrão Mediator é um padrão de design que ajuda a reduzir dependências diretas entre componentes de um aplicativo. Em termos mais simples, ele atua como um intermediário que cuida da comunicação entre as diferentes partes de um aplicativo.

Implementando Notificações

Suponha que queiramos implementar um sistema de notificação em um aplicativo ASP.NET Core.

Numa abordagem tradicional, cada componente que necessita enviar uma notificação pode interagir diretamente com um serviço de notificação. No entanto, isso pode levar a um código fortemente acoplado, dificultando o gerenciamento ou o teste.

É aqui entra em cena o MediatR.

Usando o MediatR, em vez de os componentes chamarem o serviço de notificação diretamente, eles enviam uma mensagem ao MediatR, que a encaminha para o manipulador apropriado.

Para isso basta instalar o pacote MediatR no seu projeto ASP.NET Core : install-Package MediatR

A seguir crie uma classe para definir as mensagens das notificações. Como exemplo podemos criar uma classe UserRegisteredNotification que acionará uma notificação que será enviada aos usuários que realizarem um registro em uma aplicação.

public class UserRegisteredNotification : INotification
{
    public string UserName { get; set; }
}

A interface INotification é parte do pacote MediatR sendo usada para representar mensagens ou notificações que podem ser transmitidas por meio do mediador.

A seguir vamos criar um Handler - UserRegisteredNotificationHandler - para tratar a notificação e vai imprimir a mensagem para o console quando ele receber a notificação

public class UserRegisteredNotificationHandler : INotificationHandler
{
    public Task Handle(UserRegisteredNotification notification, 
                       CancellationToken cancellationToken)
    {
        // outra lógica de processamento
        Console.WriteLine($"Usuário registrado : 
                       {notification.UserName}");

        return Task.CompletedTask;
    }
}

Esse código representa um manipulador de notificação (UserRegisteredNotificationHandler) associado a uma notificação específica (UserRegisteredNotification) no contexto do padrão de design Mediator.

Vamos entender o código:

public class UserRegisteredNotificationHandler : INotificationHandler<UserRegisteredNotification>:
A classe UserRegisteredNotificationHandler implementa a interface INotificationHandler<T> com T sendo UserRegisteredNotification. Esta interface faz parte do padrão Mediator e é usada para definir classes que manipulam notificações específicas.
public Task Handle(UserRegisteredNotification notification, CancellationToken cancellationToken):
A classe implementa o método Handle, que é chamado quando uma notificação (UserRegisteredNotification, neste caso) é enviada aos manipuladores associados. O método aceita dois parâmetros: a notificação em si (UserRegisteredNotification) e um token de cancelamento (CancellationToken), que pode ser usado para cancelar a operação assíncrona.
Console.WriteLine($"Usuário registrado : {notification.UserName}"):
Dentro do método Handle, temos uma mensagem no console indicando que um usuário foi registrado, exibindo o nome de usuário associado à notificação.
return Task.CompletedTask;:
O método retorna uma Task concluída (Task.CompletedTask). Isso é comum em manipuladores de notificação quando não é necessário retornar uma tarefa em andamento, pois o manipulador realiza seu trabalho de forma síncrona.

Configurando e usando o MeditaR

Na configuração de inicialização da aplicação, precisamos registrar o MediatR e seus manipuladores.

O código a seguir verifica todo o assembly em busca de manipuladores e os registra.

services.AddMediatR(cfg => cfg.RegisterServicesFromAssemblyContaining<Startup>());

Agora podemos usar o MediatR na aplicação ASP.NET Core.

Por exemplo, em um método de registro de usuário onde após realizar o cadastro um usuário, uma notificação é publicada através do MediatR.

public async Task RegisterUser(string userName)
{
    // Lógica para registrar o usuário..

    // Notificação via MediatR
    await _mediator.Publish(new UserRegisteredNotification 
    { 
      UserName = userName 
    });
}

O fluxo do código usado foi o seguinte:

Definindo a Notificação:
UserRegisteredNotification é uma classe que atua como uma mensagem. É uma forma de informar outras partes do sistema que um usuário se registrou.

Criando um manipulador:
UserRegisteredNotificationHandler é onde a ação acontece em resposta à notificação. É separado de onde a notificação é publicada, o que ajuda a manter o código fracamente acoplado.

Configurando o MediatR:
Esta etapa diz ao aplicativo para usar o MediatR e onde encontrar os manipuladores.

Usando MediatR:
Em vez de invocar diretamente o manipulador, o método de registro publica uma notificação. MediatR se encarrega de encontrar o manipulador certo e invocá-lo.

Vantagens desta abordagem

- Os componentes não dependem diretamente uns dos outros. Eles se comunicam apenas via MediatR. (´acoplamento fraco)
- Como os componentes são fracamente acoplados, eles podem ser testados de forma independente.

Além disso, podemos adicionar facilmente mais manipuladores para a mesma notificação ou alterar os existentes sem afetar o restante do sistema.

Desta forma a biblioteca MediatR fornece uma maneira limpa de separar preocupações em um aplicativo, facilitando o gerenciamento e a evolução de sua base de código.

E estamos conversados...

"Quem é fiel no mínimo, também é fiel no muito; quem é injusto no mínimo, também é injusto no muito."
Lucas 16:10

Referências:

José Carlos Macoratti