CQRS and the Mediator Pattern in .NET: MediatR and Beyond

builder.Services.AddMediator((MediatorOptions options) =>
{
    // Singleton is fastest, but these handlers depend on a scoped DbContext.
    options.ServiceLifetime = ServiceLifetime.Scoped;
});
builder.Services.AddScoped(typeof(IPipelineBehavior<,>), typeof(TimingBehavior<,>));

public sealed record PlaceOrder(Guid CustomerId, IReadOnlyList<OrderLineInput> Lines)
    : ICommand<Guid>;

public sealed class PlaceOrderHandler(ShopDbContext db, IPriceList prices, TimeProvider clock)
    : ICommandHandler<PlaceOrder, Guid>
{
    public async ValueTask<Guid> Handle(PlaceOrder command, CancellationToken cancellationToken)
    {
        var order = Order.Create(command.CustomerId, clock.GetUtcNow());
        foreach (var line in command.Lines)
            order.AddLine(line.Sku, line.Quantity,
                await prices.GetPriceAsync(line.Sku, cancellationToken));

        order.Submit();
        db.Orders.Add(order);
        await db.SaveChangesAsync(cancellationToken);
        return order.Id;
    }
}

public sealed class TimingBehavior<TMessage, TResponse>(
    ILogger<TimingBehavior<TMessage, TResponse>> logger)
    : IPipelineBehavior<TMessage, TResponse> where TMessage : notnull, IMessage
{
    public async ValueTask<TResponse> Handle(TMessage message,
        MessageHandlerDelegate<TMessage, TResponse> next, CancellationToken cancellationToken)
    {
        var started = Stopwatch.GetTimestamp();
        var response = await next(message, cancellationToken);
        logger.LogInformation("{Message} took {ElapsedMs:0.0} ms",
            typeof(TMessage).Name, Stopwatch.GetElapsedTime(started).TotalMilliseconds);
        return response;
    }
}

builder.Host.UseWolverine(opts =>
{
    // Use Wolverine purely as an in-process mediator for now.
    opts.Durability.Mode = DurabilityMode.MediatorOnly;
});

var app = builder.Build();
app.MapPost("/orders", (PlaceOrder command, IMessageBus bus) => bus.InvokeAsync<Guid>(command));

// Discovered by convention: a public class whose name ends in "Handler".
public static class PlaceOrderHandler
{
    public static async Task<Guid> Handle(PlaceOrder command, ShopDbContext db,
        IPriceList prices, TimeProvider clock, CancellationToken ct)
    {
        var order = Order.Create(command.CustomerId, clock.GetUtcNow());
        foreach (var line in command.Lines)
            order.AddLine(line.Sku, line.Quantity, await prices.GetPriceAsync(line.Sku, ct));

        order.Submit();
        db.Orders.Add(order);
        await db.SaveChangesAsync(ct);
        return order.Id;
    }
}

public interface ICommandHandler<in TCommand, TResult>
{
    Task<TResult> HandleAsync(TCommand command, CancellationToken ct);
}

public interface IQueryHandler<in TQuery, TResult>
{
    Task<TResult> HandleAsync(TQuery query, CancellationToken ct);
}

public sealed class LoggingDecorator<TCommand, TResult>(
    ICommandHandler<TCommand, TResult> inner,
    ILogger<LoggingDecorator<TCommand, TResult>> logger) : ICommandHandler<TCommand, TResult>
{
    public async Task<TResult> HandleAsync(TCommand command, CancellationToken ct)
    {
        using var scope = logger.BeginScope("Command {Command}", typeof(TCommand).Name);
        var result = await inner.HandleAsync(command, ct);
        logger.LogInformation("Command succeeded");
        return result;
    }
}

public static class HandlerRegistration
{
    public static IServiceCollection AddCommandHandler<TCommand, TResult, THandler>(
        this IServiceCollection services)
        where THandler : class, ICommandHandler<TCommand, TResult>
    {
        services.AddScoped<THandler>();
        services.AddScoped<ICommandHandler<TCommand, TResult>>(sp =>
            ActivatorUtilities.CreateInstance<LoggingDecorator<TCommand, TResult>>(
                sp, sp.GetRequiredService<THandler>()));
        return services;
    }
}

// Program.cs
builder.Services.AddCommandHandler<PlaceOrder, Guid, PlaceOrderHandler>();

app.MapPost("/orders", (PlaceOrder command, ICommandHandler<PlaceOrder, Guid> handler,
    CancellationToken ct) => handler.HandleAsync(command, ct));