Реализация CQRS с MediatR на C# .NET

// Через консоль
dotnet new webapi -n CQRSWithMediatR
cd CQRSWithMediatR
 
// Установка основных пакетов
dotnet add package MediatR
dotnet add package MediatR.Extensions.Microsoft.DependencyInjection

// Для валидации
dotnet add package FluentValidation
dotnet add package FluentValidation.DependencyInjectionExtensions
 
// Для работы с БД (пример с Entity Framework Core)
dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer

// Program.cs
var builder = WebApplication.CreateBuilder(args);
 
// Регистрация MediatR
builder.Services.AddMediatR(cfg => 
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));
 
// Альтернативный вариант для более ранних версий MediatR
// builder.Services.AddMediatR(typeof(Program).Assembly);
 
var app = builder.Build();
// ...

// Запрос, возвращающий данные
public record GetProductQuery(int Id) : IRequest<ProductDto>;
 
// Команда, возвращающая результат операции (например, ID созданного объекта)
public record CreateProductCommand(string Name, decimal Price) : IRequest<int>;
 
// Команда без возвращаемого значения
public record DeleteProductCommand(int Id) : IRequest;

public class GetProductQueryHandler : IRequestHandler<GetProductQuery, ProductDto>
{
    private readonly ApplicationDbContext _dbContext;
 
    public GetProductQueryHandler(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }
 
    public async Task<ProductDto> Handle(GetProductQuery request, CancellationToken cancellationToken)
    {
        var product = await _dbContext.Products
            .AsNoTracking() // Оптимизация для запросов
            .FirstOrDefaultAsync(p => p.Id == request.Id, cancellationToken);
            
        if (product == null)
            throw new NotFoundException($"Product with ID {request.Id} not found");
            
        return new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Price = product.Price
        };
    }
}

public class CreateProductCommandHandler : IRequestHandler<CreateProductCommand, int>
{
    private readonly ApplicationDbContext _dbContext;
    private readonly IMediator _mediator;
 
    public CreateProductCommandHandler(
        ApplicationDbContext dbContext,
        IMediator mediator)
    {
        _dbContext = dbContext;
        _mediator = mediator;
    }
 
    public async Task<int> Handle(CreateProductCommand request, CancellationToken cancellationToken)
    {
        var product = new Product
        {
            Name = request.Name,
            Price = request.Price,
            CreatedAt = DateTime.UtcNow
        };
 
        _dbContext.Products.Add(product);
        await _dbContext.SaveChangesAsync(cancellationToken);
        
        // Публикация события после успешного создания
        await _mediator.Publish(new ProductCreatedEvent(product.Id), cancellationToken);
        
        return product.Id;
    }
}

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IMediator _mediator;
 
    public ProductsController(IMediator mediator)
    {
        _mediator = mediator;
    }
 
    [HttpGet("{id}")]
    public async Task<ActionResult<ProductDto>> Get(int id)
    {
        try
        {
            var product = await _mediator.Send(new GetProductQuery(id));
            return Ok(product);
        }
        catch (NotFoundException ex)
        {
            return NotFound(ex.Message);
        }
    }
 
    [HttpPost]
    public async Task<ActionResult<int>> Create(CreateProductCommand command)
    {
        var productId = await _mediator.Send(command);
        return CreatedAtAction(nameof(Get), new { id = productId }, productId);
    }
}

Controllers/
Models/
Services/
Repositories/

public static class CreateProduct
{
    // Команда
    public record Command(string Name, decimal Price) : IRequest<int>;
    
    // Обработчик
    public class Handler : IRequestHandler<Command, int>
    {
        private readonly ApplicationDbContext _context;
        
        public Handler(ApplicationDbContext context)
        {
            _context = context;
        }
        
        public async Task<int> Handle(Command request, CancellationToken cancellationToken)
        {
            var product = new Product
            {
                Name = request.Name,
                Price = request.Price,
                CreatedAt = DateTime.UtcNow
            };
            
            _context.Products.Add(product);
            await _context.SaveChangesAsync(cancellationToken);
            
            return product.Id;
        }
    }
    
    // Валидатор (если используется FluentValidation)
    public class Validator : AbstractValidator<Command>
    {
        public Validator()
        {
            RuleFor(x => x.Name).NotEmpty().MaximumLength(100);
            RuleFor(x => x.Price).GreaterThan(0);
        }
    }
}

builder.Services.AddMediatR(cfg => {
    // Регистрация обработчиков из указанных сборок
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly);
    
    // Можно добавить несколько сборок
    cfg.RegisterServicesFromAssembly(typeof(SomeTypeFromAnotherAssembly).Assembly);
    
    // Кастомизация регистрации
    cfg.Lifetime = ServiceLifetime.Scoped; // по умолчанию Transient
});

// Ручная регистрация конкретного обработчика
services.AddTransient<IRequestHandler<MySpecialCommand, Unit>, MySpecialCommandHandler>();
 
// Условная регистрация с фильтрацией по атрибутам или другим критериям
services.AddMediatR(cfg => {
    cfg.RegisterServicesFromAssemblyContaining<Program>();
    
    // Добавление фильтра для исключения обработчиков с определенным атрибутом
    cfg.RegistrationStrategy = RegistrationStrategy.Skip(t => 
        t.GetCustomAttributes(typeof(ExcludeFromRegistrationAttribute), true).Any());
});

// Запрос, возвращающий DTO
public record GetProductDetailsQuery(int Id) : IRequest<ProductDetailsDto>;
 
// Соответствующий DTO
public class ProductDetailsDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public DateTime CreatedAt { get; set; }
    public string Category { get; set; }
    public List<ReviewDto> Reviews { get; set; } = new();
}

public record SearchProductsQuery : IRequest<List<ProductSummaryDto>>
{
    public string? NameContains { get; init; }
    public decimal? MinPrice { get; init; }
    public decimal? MaxPrice { get; init; }
    public string? Category { get; init; }
    public int Page { get; init; } = 1;
    public int PageSize { get; init; } = 10;
    public string? SortBy { get; init; }
    public bool SortDescending { get; init; }
}

public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, int>
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IMediator _mediator;
    
    public CreateOrderCommandHandler(IUnitOfWork unitOfWork, IMediator mediator)
    {
        _unitOfWork = unitOfWork;
        _mediator = mediator;
    }
    
    public async Task<int> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
    {
        // Начало транзакции
        await _unitOfWork.BeginTransactionAsync();
        
        try
        {
            // Создание заказа
            var order = new Order
            {
                CustomerId = request.CustomerId,
                OrderDate = DateTime.UtcNow,
                Status = OrderStatus.Created
            };
            
            // Добавление позиций заказа
            foreach (var item in request.Items)
            {
                order.AddItem(item.ProductId, item.Quantity, item.Price);
            }
            
            // Сохранение заказа
            await _unitOfWork.Orders.AddAsync(order);
            await _unitOfWork.SaveChangesAsync(cancellationToken);
            
            // Публикация события внутри той же транзакции
            await _mediator.Publish(new OrderCreatedEvent(order.Id), cancellationToken);
            
            // Если все успешно, коммит транзакции
            await _unitOfWork.CommitTransactionAsync();
            
            return order.Id;
        }
        catch
        {
            // При ошибке откат транзакции
            await _unitOfWork.RollbackTransactionAsync();
            throw;
        }
    }
}

public async Task<int> Handle(CreateOrderCommand command, CancellationToken cancellationToken)
{
    using var transaction = await _dbContext.Database.BeginTransactionAsync(cancellationToken);
    try
    {
        // Логика обработки команды
        
        await _dbContext.SaveChangesAsync(cancellationToken);
        await transaction.CommitAsync(cancellationToken);
        
        return orderId;
    }
    catch
    {
        await transaction.RollbackAsync(cancellationToken);
        throw;
    }
}

// Доменное событие
public record ProductPriceChangedEvent(int ProductId, decimal OldPrice, decimal NewPrice) : INotification;
 
// Обработчик события
public class ProductPriceChangedHandler : INotificationHandler<ProductPriceChangedEvent>
{
    private readonly IEmailService _emailService;
    
    public ProductPriceChangedHandler(IEmailService emailService)
    {
        _emailService = emailService;
    }
    
    public async Task Handle(ProductPriceChangedEvent notification, CancellationToken cancellationToken)
    {
        // Отправка уведомления подписчикам об изменении цены
        await _emailService.NotifyPriceChangeAsync(
            notification.ProductId, 
            notification.OldPrice, 
            notification.NewPrice,
            cancellationToken);
    }
}

await _mediator.Publish(new ProductPriceChangedEvent(product.Id, oldPrice, product.Price), cancellationToken);

public class ExceptionHandlingBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly ILogger<ExceptionHandlingBehavior<TRequest, TResponse>> _logger;
 
    public ExceptionHandlingBehavior(
        ILogger<ExceptionHandlingBehavior<TRequest, TResponse>> logger)
    {
        _logger = logger;
    }
 
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        try
        {
            return await next();
        }
        catch (ValidationException ex)
        {
            _logger.LogWarning(ex, "Валидация не пройдена для {RequestName}", 
                typeof(TRequest).Name);
            throw;
        }
        catch (NotFoundException ex)
        {
            _logger.LogWarning(ex, "Ресурс не найден для {RequestName} с {ExceptionMessage}", 
                typeof(TRequest).Name, ex.Message);
            throw;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Необработанная ошибка для {RequestName}", 
                typeof(TRequest).Name);
            throw new ApplicationException(
                $"Произошла ошибка при обработке запроса {typeof(TRequest).Name}", ex);
        }
    }
}

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

public interface ICommandQueue
{
    Task EnqueueAsync<TCommand>(TCommand command) where TCommand : IRequest;
}
 
public class RabbitMqCommandQueue : ICommandQueue
{
    private readonly IModel _channel;
    private readonly JsonSerializerSettings _serializerSettings;
 
    public RabbitMqCommandQueue(IConnection connection)
    {
        _channel = connection.CreateModel();
        _channel.QueueDeclare("commands", durable: true, exclusive: false, 
            autoDelete: false);
        _serializerSettings = new JsonSerializerSettings
        {
            TypeNameHandling = TypeNameHandling.All
        };
    }
 
    public Task EnqueueAsync<TCommand>(TCommand command) where TCommand : IRequest
    {
        var messageBody = Encoding.UTF8.GetBytes(
            JsonConvert.SerializeObject(command, _serializerSettings));
            
        _channel.BasicPublish(exchange: "", routingKey: "commands", 
            body: messageBody);
            
        return Task.CompletedTask;
    }
}

public class CommandQueueConsumer : BackgroundService
{
    private readonly IModel _channel;
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly JsonSerializerSettings _serializerSettings;
 
    public CommandQueueConsumer(IConnection connection, IServiceScopeFactory scopeFactory)
    {
        _channel = connection.CreateModel();
        _scopeFactory = scopeFactory;
        _serializerSettings = new JsonSerializerSettings
        {
            TypeNameHandling = TypeNameHandling.All
        };
    }
 
    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var consumer = new EventingBasicConsumer(_channel);
        
        consumer.Received += async (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var message = Encoding.UTF8.GetString(body);
            
            try
            {
                // Десериализация команды с сохранением типа
                var commandObj = JsonConvert.DeserializeObject(message, _serializerSettings);
                
                using var scope = _scopeFactory.CreateScope();
                var mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
                
                // Динамическая отправка команды
                await mediator.Send(commandObj, stoppingToken);
                
                _channel.BasicAck(ea.DeliveryTag, false);
            }
            catch (Exception)
            {
                // Обработка ошибок, возможно возврат в очередь 
                // или перемещение в очередь "мертвых писем"
                _channel.BasicNack(ea.DeliveryTag, false, requeue: false);
            }
        };
        
        _channel.BasicConsume(queue: "commands", autoAck: false, consumer: consumer);
        
        return Task.CompletedTask;
    }
}

public class RetryBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly ILogger<RetryBehavior<TRequest, TResponse>> _logger;
    private readonly int _retryCount;
    private readonly int _delayMilliseconds;
 
    public RetryBehavior(ILogger<RetryBehavior<TRequest, TResponse>> logger, 
        int retryCount = 3, int delayMilliseconds = 1000)
    {
        _logger = logger;
        _retryCount = retryCount;
        _delayMilliseconds = delayMilliseconds;
    }
 
    public async Task<TResponse> Handle(TRequest request, 
        RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
    {
        int retryAttempt = 0;
        Exception lastException = null;
 
        while (retryAttempt <= _retryCount)
        {
            try
            {
                // Если это не первая попытка, добавляем задержку
                if (retryAttempt > 0)
                {
                    int delay = _delayMilliseconds * (int)Math.Pow(2, retryAttempt - 1);
                    _logger.LogWarning("Повторная попытка {RetryAttempt} для {RequestName} через {Delay}мс", 
                        retryAttempt, typeof(TRequest).Name, delay);
                    await Task.Delay(delay, cancellationToken);
                }
 
                return await next();
            }
            catch (Exception ex) when (IsTransientException(ex))
            {
                lastException = ex;
                _logger.LogWarning(ex, "Транзиентная ошибка при выполнении {RequestName}, попытка {RetryAttempt}", 
                    typeof(TRequest).Name, retryAttempt);
                retryAttempt++;
            }
            catch (Exception ex)
            {
                // Нетранзиентная ошибка - пробрасываем без повторных попыток
                _logger.LogError(ex, "Нетранзиентная ошибка при выполнении {RequestName}", 
                    typeof(TRequest).Name);
                throw;
            }
        }
 
        throw new MaxRetryAttemptsExceededException($"Превышено максимальное количество попыток ({_retryCount}) для {typeof(TRequest).Name}", 
            lastException);
    }
 
    private bool IsTransientException(Exception exception)
    {
        // Логика определения транзиентных ошибок
        // Можно использовать готовые решения вроде Polly
        return exception is TimeoutException
            || exception is IOException
            || (exception is SqlException sqlEx && (
                sqlEx.Number == -2 || // Timeout
                sqlEx.Number == 4060 || // Cannot open database
                sqlEx.Number == 40613 // Database unavailable
            ));
    }
}

// Регистрация Polly в MediatR
builder.Services.AddTransient(typeof(IPipelineBehavior<,>), typeof(PolicyBehavior<,>));
 
// Пример поведения с использованием Polly
public class PolicyBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly IAsyncPolicy _policy;
    
    public PolicyBehavior()
    {
        _policy = Policy
            .Handle<SqlException>(ex => ex.Number == -2)
            .Or<TimeoutException>()
            .WaitAndRetryAsync(3, retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
    }
    
    public async Task<TResponse> Handle(TRequest request, 
        RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
    {
        return await _policy.ExecuteAsync(() => next());
    }
}

public class ValidationBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<IValidator<TRequest>> _validators;
 
    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
    {
        _validators = validators;
    }
 
    public async Task<TResponse> Handle(TRequest request, 
        RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
    {
        if (_validators.Any())
        {
            var context = new ValidationContext<TRequest>(request);
            
            // Выполняем все валидаторы параллельно
            var validationResults = await Task.WhenAll(
                _validators.Select(v => 
                    v.ValidateAsync(context, cancellationToken)));
            
            var failures = validationResults
                .SelectMany(r => r.Errors)
                .Where(f => f != null)
                .ToList();
 
            if (failures.Count != 0)
                throw new ValidationException(failures);
        }
        
        return await next();
    }
}

public class CreateProductCommandValidator : AbstractValidator<CreateProductCommand>
{
    public CreateProductCommandValidator()
    {
        RuleFor(p => p.Name)
            .NotEmpty().WithMessage("Имя продукта обязательно")
            .MaximumLength(100).WithMessage("Имя продукта не должно превышать 100 символов");
            
        RuleFor(p => p.Price)
            .GreaterThan(0).WithMessage("Цена должна быть больше нуля")
            .LessThan(1000000).WithMessage("Цена не может быть больше 1,000,000");
            
        RuleFor(p => p.CategoryId)
            .NotEmpty().WithMessage("Категория обязательна");
    }
}

public class ExceptionHandlingBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly ILogger<ExceptionHandlingBehavior<TRequest, TResponse>> _logger;
    
    public ExceptionHandlingBehavior(
        ILogger<ExceptionHandlingBehavior<TRequest, TResponse>> logger)
    {
        _logger = logger;
    }
    
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        try
        {
            return await next();
        }
        catch (ValidationException ex)
        {
            _logger.LogWarning("Ошибка валидации: {Message}", ex.Message);
            throw new ApiValidationException(ex.Errors);
        }
        catch (DomainException ex)
        {
            _logger.LogWarning("Бизнес-ошибка: {Message}", ex.Message);
            throw new ApiBusinessException(ex.Message);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Необработанное исключение: {Message}", ex.Message);
            throw new ApiServerException("Произошла внутренняя ошибка сервера");
        }
    }
}

services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ExceptionHandlingBehavior<,>));

// Интерфейс для отложенной обработки
public interface ICommandQueue
{
    Task EnqueueAsync<TCommand>(TCommand command) where TCommand : IRequest;
}
 
// Реализация с использованием MassTransit и RabbitMQ
public class MassTransitCommandQueue : ICommandQueue
{
    private readonly IBus _bus;
    
    public MassTransitCommandQueue(IBus bus)
    {
        _bus = bus;
    }
    
    public async Task EnqueueAsync<TCommand>(TCommand command) where TCommand : IRequest
    {
        await _bus.Publish(command);
    }
}

public class CommandConsumer<TCommand> : IConsumer<TCommand> where TCommand : IRequest
{
    private readonly IMediator _mediator;
    
    public CommandConsumer(IMediator mediator)
    {
        _mediator = mediator;
    }
    
    public async Task Consume(ConsumeContext<TCommand> context)
    {
        await _mediator.Send(context.Message, context.CancellationToken);
    }
}

[HttpPost]
public async Task<IActionResult> ProcessLongRunningTask(ProcessLongRunningCommand command)
{
    // Помещаем команду в очередь вместо прямого выполнения
    await _commandQueue.EnqueueAsync(command);
    
    // Сразу возвращаем ответ клиенту
    return Accepted();
}

public class RetryBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly ILogger<RetryBehavior<TRequest, TResponse>> _logger;
    private readonly RetryPolicy _retryPolicy;
    
    public RetryBehavior(ILogger<RetryBehavior<TRequest, TResponse>> logger)
    {
        _logger = logger;
        
        // Использование Polly для определения политики повторных попыток
        _retryPolicy = Policy
            .Handle<SqlException>(ex => IsTransientError(ex))
            .Or<TimeoutException>()
            .WaitAndRetryAsync(
                3, // количество повторных попыток
                attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), // экспоненциальная задержка
                (exception, timeSpan, retryCount, context) =>
                {
                    _logger.LogWarning(
                        exception, 
                        "Попытка {RetryCount} завершилась ошибкой. Повтор через {RetryDelay}...", 
                        retryCount, timeSpan);
                });
    }
    
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        // Применяем политику повторов только к командам
        if (typeof(TRequest).IsAssignableTo(typeof(ICommand)))
        {
            return await _retryPolicy.ExecuteAsync(() => next());
        }
        
        // Для запросов выполняем без повторов
        return await next();
    }
    
    private bool IsTransientError(SqlException ex)
    {
        // Коды ошибок SQL Server, которые считаются транзиентными
        int[] transientErrorNumbers = { 4060, 40197, 40501, 40613, 49918, 49919, 49920 };
        return transientErrorNumbers.Contains(ex.Number);
    }
}

public class ValidationBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<IValidator<TRequest>> _validators;
    
    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
    {
        _validators = validators;
    }
    
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        if (!_validators.Any())
            return await next();
            
        // Создаем контекст валидации
        var context = new ValidationContext<TRequest>(request);
        
        // Выполняем все валидаторы параллельно
        var validationResults = await Task.WhenAll(
            _validators.Select(v => v.ValidateAsync(context, cancellationToken)));
        
        // Собираем все ошибки из результатов валидации
        var failures = validationResults
            .SelectMany(r => r.Errors)
            .Where(f => f != null)
            .ToList();
            
        if (failures.Any())
            throw new ValidationException(failures);
            
        return await next();
    }
}

public class CreateProductCommandValidator : AbstractValidator<CreateProductCommand>
{
    public CreateProductCommandValidator(ApplicationDbContext dbContext)
    {
        RuleFor(x => x.Name)
            .NotEmpty().WithMessage("Название продукта обязательно")
            .MaximumLength(200).WithMessage("Название не должно превышать 200 символов");
            
        RuleFor(x => x.Price)
            .GreaterThan(0).WithMessage("Цена должна быть положительной");
            
        RuleFor(x => x.CategoryId)
            .MustAsync(async (categoryId, cancellation) => {
                return await dbContext.Categories
                    .AnyAsync(c => c.Id == categoryId, cancellation);
            }).WithMessage("Указанная категория не существует");
    }
}

public class CachingBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly IMemoryCache _cache;
    private readonly ICacheKeyService _cacheKeyService;
    
    public CachingBehavior(
        IMemoryCache cache,
        ICacheKeyService cacheKeyService)
    {
        _cache = cache;
        _cacheKeyService = cacheKeyService;
    }
    
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        // Кэшируем только запросы, помеченные атрибутом Cachable
        if (request is not ICachableQuery<TResponse> cachableQuery)
            return await next();
            
        var cacheKey = _cacheKeyService.GetCacheKey(request);
        
        // Проверяем наличие результата в кэше
        if (_cache.TryGetValue(cacheKey, out TResponse cachedResponse))
            return cachedResponse;
            
        // Если в кэше нет, выполняем запрос
        var response = await next();
        
        // Помещаем результат в кэш с указанным временем жизни
        _cache.Set(
            cacheKey, 
            response, 
            TimeSpan.FromSeconds(cachableQuery.CacheTimeInSeconds));
            
        return response;
    }
}

public class PerformanceBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly ILogger<PerformanceBehavior<TRequest, TResponse>> _logger;
    private readonly Stopwatch _timer;
    
    public PerformanceBehavior(
        ILogger<PerformanceBehavior<TRequest, TResponse>> logger)
    {
        _logger = logger;
        _timer = new Stopwatch();
    }
    
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        _timer.Start();
        
        var response = await next();
        
        _timer.Stop();
        
        var elapsedMilliseconds = _timer.ElapsedMilliseconds;
        
        if (elapsedMilliseconds > 500)
        {
            var requestName = typeof(TRequest).Name;
            
            _logger.LogWarning(
                "CQRS Long Running Request: {Name} ({ElapsedMilliseconds} ms)",
                requestName, elapsedMilliseconds);
        }
        
        return response;
    }
}

// Маркерный интерфейс для идемпотентных команд
public interface IIdempotentCommand : IRequest
{
    Guid CommandId { get; }
}
 
// Пример команды
public record ProcessPaymentCommand : IIdempotentCommand
{
    public Guid CommandId { get; init; } = Guid.NewGuid();
    public Guid OrderId { get; init; }
    public decimal Amount { get; init; }
}
 
// Behavior для обеспечения идемпотентности
public class IdempotencyBehavior<TRequest, TResponse> 
    : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
    private readonly IIdempotencyStore _idempotencyStore;
    
    public IdempotencyBehavior(IIdempotencyStore idempotencyStore)
    {
        _idempotencyStore = idempotencyStore;
    }
    
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        // Обрабатываем только идемпотентные команды
        if (request is not IIdempotentCommand idempotentCommand)
            return await next();
            
        // Проверяем, была ли команда уже обработана
        var result = await _idempotencyStore.GetResultAsync<TResponse>(
            idempotentCommand.CommandId, 
            cancellationToken);
            
        if (result != null)
            return result;
            
        // Если команда ещё не обрабатывалась, выполняем её
        var response = await next();
        
        // Сохраняем результат выполнения
        await _idempotencyStore.SaveResultAsync(
            idempotentCommand.CommandId, 
            response,
            cancellationToken);
            
        return response;
    }
}

// Запрос поиска книг
public record SearchBooksQuery : IRequest<SearchResultDto>
{
    public string SearchTerm { get; init; } = string.Empty;
    public string[] Genres { get; init; } = Array.Empty<string>();
    public int Page { get; init; } = 1;
    public int PageSize { get; init; } = 10;
}
 
// Обработчик поиска
public class SearchBooksQueryHandler : IRequestHandler<SearchBooksQuery, SearchResultDto>
{
    private readonly IBookReadRepository _bookRepository;
    
    public SearchBooksQueryHandler(IBookReadRepository bookRepository)
    {
        _bookRepository = bookRepository;
    }
    
    public async Task<SearchResultDto> Handle(SearchBooksQuery request, CancellationToken cancellationToken)
    {
        // Используем специализированные методы репозитория для чтения
        var (books, totalCount) = await _bookRepository.SearchBooksAsync(
            request.SearchTerm,
            request.Genres,
            request.Page,
            request.PageSize,
            cancellationToken);
            
        return new SearchResultDto
        {
            Books = books.Select(b => new BookSummaryDto
            {
                Id = b.Id,
                Title = b.Title,
                Author = b.Author,
                CoverUrl = b.CoverUrl,
                Rating = b.CalculateAverageRating()
            }).ToList(),
            TotalCount = totalCount,
            Page = request.Page,
            PageSize = request.PageSize,
            TotalPages = (int)Math.Ceiling((double)totalCount / request.PageSize)
        };
    }
}

// Команда добавления в коллекцию
public record AddToCollectionCommand : IRequest<Unit>
{
    public Guid UserId { get; init; }
    public Guid BookId { get; init; }
    public string CollectionName { get; init; } = "Избранное";
}
 
// Обработчик команды
public class AddToCollectionCommandHandler : IRequestHandler<AddToCollectionCommand, Unit>
{
    private readonly IUserWriteRepository _userRepository;
    private readonly IMediator _mediator;
    
    public AddToCollectionCommandHandler(
        IUserWriteRepository userRepository,
        IMediator mediator)
    {
        _userRepository = userRepository;
        _mediator = mediator;
    }
    
    public async Task<Unit> Handle(AddToCollectionCommand request, CancellationToken cancellationToken)
    {
        // Получаем пользователя из репозитория для записи
        var user = await _userRepository.GetByIdAsync(request.UserId, cancellationToken);
        if (user == null)
            throw new UserNotFoundException(request.UserId);
            
        // Вызываем доменный метод добавления книги
        var result = user.AddBookToCollection(request.BookId, request.CollectionName);
        
        // Сохраняем изменения
        await _userRepository.SaveChangesAsync(cancellationToken);
        
        // Публикуем событие о добавлении книги в коллекцию
        await _mediator.Publish(new BookAddedToCollectionEvent(
            request.UserId,
            request.BookId,
            request.CollectionName), cancellationToken);
            
        return Unit.Value;
    }
}

// Команда создания заказа
public record CreateOrderCommand : IRequest<OrderCreatedResultDto>
{
    public Guid CustomerId { get; init; }
    public List<OrderItemDto> Items { get; init; } = new();
    public AddressDto ShippingAddress { get; init; }
    public string PaymentMethodId { get; init; }
}
 
// Обработчик создания заказа
public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, OrderCreatedResultDto>
{
    private readonly IOrderRepository _orderRepository;
    private readonly ICustomerRepository _customerRepository;
    private readonly IProductRepository _productRepository;
    private readonly IInventoryService _inventoryService;
    private readonly IPaymentService _paymentService;
    private readonly IMediator _mediator;
    
    // ... конструктор с внедрением зависимостей
    
    public async Task<OrderCreatedResultDto> Handle(CreateOrderCommand command, CancellationToken cancellationToken)
    {
        // Начало транзакции
        using var transaction = await _orderRepository.BeginTransactionAsync();
        
        try
        {
            // Проверка наличия и резервирование товаров
            var inventoryCheck = await _inventoryService.CheckAndReserveInventoryAsync(
                command.Items.Select(i => new InventoryItem(i.ProductId, i.Quantity)).ToList(),
                cancellationToken);
                
            if (!inventoryCheck.AllItemsAvailable)
                throw new InsufficientInventoryException(inventoryCheck.UnavailableItems);
                
            // Получение информации о ценах продуктов
            var products = await _productRepository.GetProductsByIdsAsync(
                command.Items.Select(i => i.ProductId).ToList(),
                cancellationToken);
                
            // Создание объекта заказа с применением бизнес-правил
            var customer = await _customerRepository.GetByIdAsync(command.CustomerId, cancellationToken);
            var order = new Order(customer);
            
            foreach (var item in command.Items)
            {
                var product = products.FirstOrDefault(p => p.Id == item.ProductId);
                if (product == null)
                    throw new ProductNotFoundException(item.ProductId);
                    
                order.AddItem(product, item.Quantity);
            }
            
            order.SetShippingAddress(
                new Address(
                    command.ShippingAddress.Street,
                    command.ShippingAddress.City,
                    command.ShippingAddress.State,
                    command.ShippingAddress.PostalCode,
                    command.ShippingAddress.Country));
                    
            // Обработка платежа
            var paymentResult = await _paymentService.ProcessPaymentAsync(
                command.PaymentMethodId,
                order.TotalAmount,
                cancellationToken);
                
            if (!paymentResult.Success)
                throw new PaymentFailedException(paymentResult.ErrorMessage);
                
            order.SetPaymentId(paymentResult.TransactionId);
            
            // Сохранение заказа
            await _orderRepository.AddAsync(order, cancellationToken);
            await _orderRepository.SaveChangesAsync(cancellationToken);
            
            // Публикация событий
            await _mediator.Publish(new OrderCreatedEvent(order.Id), cancellationToken);
            
            // Фиксация транзакции
            await transaction.CommitAsync(cancellationToken);
            
            return new OrderCreatedResultDto
            {
                OrderId = order.Id,
                TotalAmount = order.TotalAmount,
                EstimatedDeliveryDate = order.EstimatedDeliveryDate
            };
        }
        catch
        {
            await transaction.RollbackAsync(cancellationToken);
            throw;
        }
    }
}

[Fact]
public async Task GetProductDetails_ForExistingProduct_ReturnsCorrectData()
{
    // Arrange
    var product = new Product
    {
        Id = 1,
        Name = "Test Product",
        Description = "Test Description",
        Price = 29.99m,
        CategoryId = 2
    };
    
    var mockRepository = new Mock<IProductRepository>();
    mockRepository
        .Setup(r => r.GetByIdAsync(It.Is<int>(id => id == 1), It.IsAny<CancellationToken>()))
        .ReturnsAsync(product);
        
    var handler = new GetProductDetailsQueryHandler(mockRepository.Object);
    var query = new GetProductDetailsQuery(1);
    
    // Act
    var result = await handler.Handle(query, CancellationToken.None);
    
    // Assert
    Assert.NotNull(result);
    Assert.Equal(1, result.Id);
    Assert.Equal("Test Product", result.Name);
    Assert.Equal(29.99m, result.Price);
}

public class ProductCommandsIntegrationTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;
    private readonly IMediator _mediator;
    
    public ProductCommandsIntegrationTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // Заменяем реальный DbContext на in-memory версию
                var descriptor = services.SingleOrDefault(d =>
                    d.ServiceType == typeof(DbContextOptions<ApplicationDbContext>));
                    
                if (descriptor != null)
                {
                    services.Remove(descriptor);
                }
                
                services.AddDbContext<ApplicationDbContext>(options =>
                {
                    options.UseInMemoryDatabase("TestDatabase");
                });
                
                // Инициализация тестовых данных
                var sp = services.BuildServiceProvider();
                using var scope = sp.CreateScope();
                var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
                db.Database.EnsureCreated();
                SeedTestData(db);
            });
        });
        
        var scope = _factory.Services.CreateScope();
        _mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
    }
    
    [Fact]
    public async Task CreateProduct_ValidCommand_ReturnsProductId()
    {
        // Arrange
        var command = new CreateProductCommand
        {
            Name = "New Product",
            Price = 19.99m,
            CategoryId = 1
        };
        
        // Act
        var productId = await _mediator.Send(command);
        
        // Assert
        Assert.True(productId > 0);
        
        // Verify product was created
        var getQuery = new GetProductDetailsQuery(productId);
        var product = await _mediator.Send(getQuery);
        
        Assert.NotNull(product);
        Assert.Equal("New Product", product.Name);
        Assert.Equal(19.99m, product.Price);
    }
    
    private void SeedTestData(ApplicationDbContext context)
    {
        // Заполнение базы тестовыми данными
        // ...
    }
}

// Сервис команд - обработка записи (упрощенно)
public class ProductCommandService
{
    private readonly IMediator _mediator;
    private readonly IEventBus _eventBus;
    
    public ProductCommandService(IMediator mediator, IEventBus eventBus)
    {
        _mediator = mediator;
        _eventBus = eventBus;
    }
    
    public async Task<int> CreateProductAsync(CreateProductRequest request)
    {
        // Преобразование API-запроса в команду
        var command = new CreateProductCommand(
            request.Name, 
            request.Price, 
            request.CategoryId);
            
        // Обработка команды
        var productId = await _mediator.Send(command);
        
        // Публикация события для синхронизации с сервисом запросов
        await _eventBus.PublishAsync(new ProductCreatedIntegrationEvent(
            productId,
            request.Name,
            request.Price,
            request.CategoryId));
            
        return productId;
    }
}
 
// Сервис запросов - обработка событий и обновление моделей чтения
public class ProductQueryService
{
    private readonly IProductReadRepository _repository;
    
    public ProductQueryService(IProductReadRepository repository)
    {
        _repository = repository;
    }
    
    // Обработка событий интеграции
    public async Task HandleProductCreatedEvent(ProductCreatedIntegrationEvent @event)
    {
        // Обновление базы данных для чтения
        await _repository.CreateProductReadModelAsync(
            @event.ProductId,
            @event.Name,
            @event.Price,
            @event.CategoryId);
    }
}