MediatR est une bibliothèque puissante qui met en œuvre le motif de conception Mediator, favorisant le découplage et l’organisation de la communication entre les différentes parties de votre application ASP.NET Core.
Parmi ses ressources, le système de notifications se démarque par sa simplicité et sa flexibilité pour communiquer des messages de réussite, d’erreur ou d’avertissement à l’utilisateur.
Les notifications de MediatR, également connues sous le nom de Publish, permettent de transmettre des messages à plusieurs gestionnaires de manière asynchrone. Ce mécanisme informe les composants de votre application d’événements ou de changements importants sans logique complexe.
Les concepts centraux impliqués dans les notifications de MediatR sont :
- IRequestHandler<TRequest, TResponse> : Interface qui définit un gestionnaire de requêtes qui reçoit un type de requête
TRequestet renvoie un type de réponseTResponse. - INotificationHandler<TNotification> : Interface qui définit un gestionnaire de notifications qui reçoit un type de notification
TNotification. - Notification : Classe de base pour toutes les notifications.
- Mediator : Classe qui met en œuvre le motif Mediator, centralisant l’envoi de requêtes et de notifications.
Imaginez le scénario où nous avons une application de Ventes en ligne qui doit notifier les clients par email ou SMS lorsque leurs commandes sont créées et terminées. En utilisant les notifications MediatR, nous pouvons accomplir cette tâche avec élégance.
Dans les applications modernes, l’exécution de tâches telles que l’envoi d’e-mails ou de notifications par SMS de manière asynchrone garantit une expérience utilisateur fluide et évite les retards inutiles. Par exemple, lors de la création d’une commande, l’objectif principal doit être de finaliser le processus de commande sans dépendre de réponses immédiates des services d’e-mail ou de SMS.
L’utilisation des Notifications MediatR permet une gestion efficace de ces tâches asynchrones, permettant à l’avancement du processus de création de commandes de progresser indépendamment. Cette approche assure la réactivité de l’application et des performances optimales lors de l’envoi des notifications par e-mail et SMS en arrière-plan, sans impacter la fonctionnalité principale du gestionnaire de création de commandes.
Vous souhaitez que les gestionnaires d’événements/notifications s’exécutent de manière indépendante et isolée. C’est ici que les messages hors processus entrent en jeu. Cependant, une seule requête peut être traitée par plusieurs gestionnaires. Certaines opérations indépendantes doivent se dérouler après certains événements.
Création du projet
Nous allons créer un projet dans VS 2022 en utilisant le gabarit ASP.NET Core Web API nommé ApiPedidosNotification pour illustrer comment envoyer des notifications en utilisant MediatR.
Après avoir créé le projet nous ajouterons le paquet Nuget MediatR au projet et dans la classe Program nous enregistrerons le service MediatR :
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// registra o MediatR
builder.Services.AddMediatR(cfg =>
cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));
var app = builder.Build();Dans ce projet nous allons créer le dossier Entities contenant la classe Pedido :
public class Pedido
{
public int Id { get; set; }
public string? ClienteNome { get; set; }
public decimal Total { get; set; }
public DateTime CriadoEm { get; set; }
}Ensuite nous allons créer un dossier Features dans le projet et, dans ce dossier, créer les sous-dossiers Commands et Notifications.
Dans le dossier Commands nous allons créer la commande et son gestionnaire pour créer une commande :
1- CriarPedidoCommand
public class CriarPedidoCommand : IRequest<Pedido>
{
public string? ClienteNome { get; set; }
public decimal ValorTotal { get; set; }
public string? ClienteEmail { get; set; }
} 2- CriarPedidoCommandHandler
public class CriarPedidoCommandHandler :
IRequestHandler<CriarPedidoCommand, Pedido>
{
private readonly IMediator _mediator;
public CriarPedidoCommandHandler(IMediator mediator)
{
_mediator = mediator;
}
public async Task<Pedido> Handle(CriarPedidoCommand request,
CancellationToken cancellationToken)
{
// Valida o request
// Cria o pedido na base (a implementar...)
var pedido = new Pedido
{
Id = 1,
ClienteNome = request.ClienteNome,
Total = request.ValorTotal
};
// Publica a notificação
await _mediator.Publish(new CriarPedidoNotification()
{ Pedido = pedido }, cancellationToken);
return pedido;
}
}La méthode Publish() de MediatR publie la notification.
Aujourd’hui dans le dossier Notifications nous allons créer la classe de notification qui implémente l’interface INotification de MediatR :
public class CriarPedidoNotification : INotification
{
public Pedido? Pedido { get; set; }
} Ensuite nous allons créer la classe CriarPedidoNotificationHandler qui agit comme le gestionnaire pour cette notification :
public class CriarPedidoNotificationHandler :
INotificationHandler<CriarPedidoNotification>
{
private readonly ILogger<CriarPedidoNotificationHandler> _logger;
public CriarPedidoNotificationHandler(
ILogger<CriarPedidoNotificationHandler> logger)
{
_logger = logger;
}
public Task Handle(CriarPedidoNotification notification,
CancellationToken cancellationToken)
{
// envoie email de confirmation
_logger.LogInformation($"Email de confirmation envoyé pour la commande :
{notification.Pedido.Id}");
return Task.CompletedTask;
}
}Ainsi, nous pouvons créer le contrôleur PedidosController dans le dossier Controllers :
[Route("api/[controller]")]
[ApiController]
public class PedidosController : ControllerBase
{
private readonly IMediator _mediator;
public PedidosController(IMediator mediator)
{
_mediator = mediator;
}
[HttpPost]
public async Task<Pedido> Create([FromBody] CriarPedidoCommand command)
{
var order = await _mediator.Send(command);
return order;
}
}En exécutant le projet, nous aurons le point d’accès /api/Pedidos qui, lorsqu’il est actionné, se comporte comme le montre l’image ci-dessous :
En cliquant sur Executer nous obtiendrons le résultat affiché sur l’image ci-dessous :
En observant la fenêtre Output, nous voyons le journal afficher le message envoyé :
Ainsi, nous avons montré de manière objective et directe à quel point il est simple d’envoyer des notifications en utilisant la bibliothèque MediatR.
Souvenez-vous que nous pouvons créer autant de gestionnaires (Handlers) que nous voulons pour une unique notification (Notification). Chaque gestionnaire interagira avec la notification d’une manière différente, vous permettant d’avoir plusieurs actions qui se produisent en réponse à une seule notification.
Par exemple, vous pouvez disposer d’une unique notification « PedidoCriadoNotification » et créer plusieurs gestionnaires pour la traiter de façons différentes.
Par exemple :
public class PedidoCriadoNotification : INotification
{
public Pedido Pedido { get; set; }
}
public class EnviarEmailPedidoCriadoHandler :
INotificationHandler<PedidoCriadoNotification>
{
public Task Handle(PedidoCriadoNotification notification,
CancellationToken cancellationToken)
{
// Logique pour envoyer l’e-mail de confirmation pour la commande créée
return Task.CompletedTask;
}
}
public class AtualizarStatusPedidoHandler :
INotificationHandler<PedidoCriadoNotification>
{
public Task Handle(PedidoCriadoNotification notification,
CancellationToken cancellationToken)
{
// Logique pour mettre à jour le statut de la commande dans le système
return Task.CompletedTask;
}
}
public class NotificarAdminsPedidoCriadoHandler :
INotificationHandler<PedidoCriadoNotification>
{
public Task Handle(PedidoCriadoNotification notification,
CancellationToken cancellationToken)
{
// Logique pour notifier les administrateurs de la nouvelle commande
return Task.CompletedTask;
}
}Chaque gestionnaire réagira à la notification PedidoCriadoNotification de manière différente. Par exemple, le EnviarEmailPedidoCriadoHandler peut envoyer un e-mail de confirmation au client, le AtualizarStatusPedidoHandler peut mettre à jour le statut de la commande dans le système et le NotificarAdminsPedidoCriadoHandler peut notifier les administrateurs de la nouvelle commande créée.
Lorsque vous publiez une seule notification PedidoCriadoNotification, tous ces gestionnaires seront déclenchés en séquence pour traiter la notification et exécuter leurs logiques respectives. C’est l’un des avantages de l’utilisation de MediatR et du motif Mediator – il permet de découpler les différentes parties de votre système et de réagir de manière flexible à des événements spécifiques.
À présent, au lieu de répéter cette logique dans le gestionnaire, nous pouvons utiliser la fonctionnalité Behavior, et, dans la suite de l’article, nous verrons comment mettre en œuvre cette fonctionnalité.
