MediatR CQRS: command/query segregation with pipeline behaviors

Controllers and services with fat method signatures mix queries and commands, accumulating cross-cutting concerns (logging, validation, transactions) inline. This makes each handler grow in complexity over time.

Use MediatR to dispatch commands and queries through a pipeline:

// Command
public record CreateOrderCommand(Guid CustomerId, List<OrderItem> Items)
    : IRequest<Guid>;

// Handler
public class CreateOrderHandler : IRequestHandler<CreateOrderCommand, Guid>
{
    private readonly AppDbContext _db;
    public CreateOrderHandler(AppDbContext db) => _db = db;

    public async Task<Guid> Handle(
        CreateOrderCommand cmd, CancellationToken ct)
    {
        var order = Order.Create(cmd.CustomerId, cmd.Items);
        _db.Orders.Add(order);
        await _db.SaveChangesAsync(ct);
        return order.Id;
    }
}

// Pipeline behavior for cross-cutting concerns
public class ValidationBehavior<TReq, TRes>
    : IPipelineBehavior<TReq, TRes> where TReq : notnull
{
    private readonly IEnumerable<IValidator<TReq>> _validators;
    public ValidationBehavior(IEnumerable<IValidator<TReq>> validators)
        => _validators = validators;

    public async Task<TRes> Handle(TReq req,
        RequestHandlerDelegate<TRes> next, CancellationToken ct)
    {
        var failures = _validators
            .SelectMany(v => v.Validate(req).Errors)
            .Where(e => e != null).ToList();
        if (failures.Count != 0)
            throw new ValidationException(failures);
        return await next();
    }
}

MediatR decouples the sender from the handler through an in-process mediator. Pipeline behaviors compose around handlers like middleware, enabling validation, logging, and transaction management without modifying individual handlers.