Sarmat.Mediator 0.1.0

Sarmat.Mediator

Bibliothèque .NET légère pour le pattern Mediator / CQRS : envoi de requêtes (Send), diffusion d’événements (Publish) et pipeline autour des gestionnaires. Pensée pour un usage proche de MediatR, sans dépendre du package MediatR.

Installation

dotnet add package Sarmat.Mediator

Ou via le gestionnaire NuGet de Visual Studio : recherchez Sarmat.Mediator.

Enregistrement (Dependency Injection)

Dans Program.cs (Minimal API) ou votre composition racine :

using Microsoft.Extensions.DependencyInjection;
using Sarmat.Mediator;

var builder = WebApplication.CreateBuilder(args);

// Scanner une ou plusieurs assemblies pour les handlers et le pipeline
builder.Services.AddSarmatMediator(typeof(Program).Assembly);

// Équivalent pratique si vos handlers sont dans le même assembly qu’un type « ancre »
// builder.Services.AddSarmatMediator<Program>();

Lifetimes par défaut (scan d’assembly) :

• IMediator → Scoped
• IRequestHandler<,>, INotificationHandler<>, IPipelineBehavior<,> → Transient

Vous pouvez enregistrer vos types manuellement si vous préférez d’autres lifetimes.

Requête / réponse

1. Définir la requête et la réponse

using Sarmat.Mediator;

public sealed record GetUserQuery(Guid UserId) : IRequest<UserDto?>;

public sealed record UserDto(Guid Id, string Name);

2. Implémenter le gestionnaire

public sealed class GetUserQueryHandler : IRequestHandler<GetUserQuery, UserDto?>
{
    public Task<UserDto?> Handle(GetUserQuery request, CancellationToken cancellationToken)
    {
        // … accès base de données, etc.
        var dto = new UserDto(request.UserId, "Alice");
        return Task.FromResult<UserDto?>(dto);
    }
}

3. Envoyer la requête

Injectez IMediator (par ex. dans un contrôleur ou un service) :

public sealed class UsersService(IMediator mediator)
{
    public Task<UserDto?> GetAsync(Guid id, CancellationToken ct = default)
        => mediator.Send(new GetUserQuery(id), ct);
}

Commande sans valeur de retour

Utilisez IRequest (équivalent à IRequest<Unit>) :

public sealed record ArchiveUserCommand(Guid UserId) : IRequest;

public sealed class ArchiveUserCommandHandler : IRequestHandler<ArchiveUserCommand, Unit>
{
    public Task<Unit> Handle(ArchiveUserCommand request, CancellationToken cancellationToken)
    {
        // …
        return Task.FromResult(Unit.Value);
    }
}

Appel :

await mediator.Send(new ArchiveUserCommand(userId), cancellationToken);

Notifications (publish / subscribe)

Plusieurs gestionnaires peuvent réagir au même événement. Ils sont exécutés l’un après l’autre (séquentiel).

public sealed record UserRegistered(Guid UserId, string Email) : INotification;

public sealed class SendWelcomeEmailHandler : INotificationHandler<UserRegistered>
{
    public Task Handle(UserRegistered notification, CancellationToken cancellationToken)
        => Task.CompletedTask;
}

public sealed class AuditUserRegisteredHandler : INotificationHandler<UserRegistered>
{
    public Task Handle(UserRegistered notification, CancellationToken cancellationToken)
        => Task.CompletedTask;
}

Publication :

await mediator.Publish(new UserRegistered(userId, email), cancellationToken);

Pipeline (comportements / « middleware »)

Les implémentations de IPipelineBehavior<TRequest, TResponse> s’exécutent autour du gestionnaire. Le premier comportement enregistré dans le conteneur est le plus externe (comme avec MediatR).

Exemple : journalisation simple.

public sealed class LoggingBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : notnull
{
    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken)
    {
        // avant le handler
        var response = await next().ConfigureAwait(false);
        // après le handler
        return response;
    }
}

Enregistrez le comportement ouvert (générique) si vous voulez qu’il s’applique à toutes les requêtes :

builder.Services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));

L’ordre d’exécution suit l’ordre d’enregistrement des types concrets de pipeline résolus pour la paire (TRequest, TResponse).

Bonnes pratiques

• Gardez les requêtes immuables (record) quand c’est possible.
• Passez toujours CancellationToken aux appels Send / Publish / Send(IRequest).
• Un seul IRequestHandler<TRequest, TResponse> par couple (TRequest, TResponse) : c’est ce que résout le médiateur.

Différences avec MediatR

• Les types vivent dans l’espace de noms Sarmat.Mediator, pas MediatR.
• L’extension d’enregistrement est AddSarmatMediator (pas AddMediatR).
• Toutes les fonctionnalités de MediatR ne sont pas reproduites (pas de parité API complète). Étendez la bibliothèque selon vos besoins.

Licence

Le package est publié sous MIT (voir le fichier de licence du dépôt ou les métadonnées NuGet).