Паттерн CQRS в C#

List<string> animals = new List<string>();
animals.Add("Тигр");        // Команда: изменяет состояние
int count = animals.Count;  // Запрос: только возвращает данные

Stack<string> stack = new Stack<string>();
stack.Push("первый");
stack.Push("второй");
string value = stack.Pop();  // Возвращает "второй" и удаляет его из стека

public class CustomerService
{
    public Customer GetCustomer(int id)
    {
        // Чтение из базы данных
        return _repository.GetById(id);
    }
 
    public void UpdateCustomer(Customer customer)
    {
        // Проверка бизнес-правил
        ValidateCustomer(customer);
        
        // Запись в базу данных
        _repository.Update(customer);
    }
}

// Команда (запись)
public class UpdateCustomerCommand : ICommand
{
    public int CustomerId { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}
 
public class UpdateCustomerCommandHandler : ICommandHandler<UpdateCustomerCommand>
{
    public void Handle(UpdateCustomerCommand command)
    {
        var customer = _repository.GetById(command.CustomerId);
        customer.Name = command.Name;
        customer.Email = command.Email;
        
        // Валидация и бизнес-правила
        _validator.ValidateAndThrow(customer);
        
        _repository.Update(customer);
    }
}
 
// Запрос (чтение)
public class GetCustomerQuery : IQuery<CustomerDto>
{
    public int CustomerId { get; set; }
}
 
public class GetCustomerQueryHandler : IQueryHandler<GetCustomerQuery, CustomerDto>
{
    public CustomerDto Handle(GetCustomerQuery query)
    {
        // Можно напрямую обращаться к базе через SQL или Dapper
        // для оптимальной производительности
        return _readDb.Query<CustomerDto>(
            "SELECT Id, Name, Email FROM Customers WHERE Id = @Id",
            new { Id = query.CustomerId }
        ).FirstOrDefault();
    }
}

public void Handle(UpdateCustomerCommand command)
{
    // Обновление модели записи
    var customer = _writeRepository.GetById(command.CustomerId);
    customer.Name = command.Name;
    _writeRepository.Update(customer);
    
    // Обновление модели чтения
    _readRepository.UpdateCustomerName(command.CustomerId, command.Name);
}

public void Handle(UpdateCustomerCommand command)
{
    // Обновление модели записи
    var customer = _writeRepository.GetById(command.CustomerId);
    customer.Name = command.Name;
    _writeRepository.Update(customer);
    
    // Публикация события
    _eventBus.Publish(new CustomerNameUpdatedEvent
    {
        CustomerId = command.CustomerId,
        NewName = command.Name
    });
}
 
// В другом месте
public void Handle(CustomerNameUpdatedEvent @event)
{
    // Обновление модели чтения
    _readRepository.UpdateCustomerName(@event.CustomerId, @event.NewName);
}

// Отправка команды
public async Task<Guid> SendCommand(UpdateCustomerCommand command)
{
    // Генерация уникального идентификатора для отслеживания команды
    var commandId = Guid.NewGuid();
    
    // Сохранение команды в очередь
    await _commandQueue.EnqueueAsync(command, commandId);
    
    // Возврат идентификатора для последующей проверки статуса
    return commandId;
}
 
// Где-то в фоновом процессе
public async Task ProcessCommandsAsync()
{
    while (true)
    {
        var commandMessage = await _commandQueue.DequeueAsync();
        try
        {
            await _commandHandlerResolver.ResolveHandler(commandMessage.Command).HandleAsync();
            await _statusRepository.SetStatusAsync(commandMessage.Id, CommandStatus.Completed);
        }
        catch (Exception ex)
        {
            await _statusRepository.SetStatusAsync(commandMessage.Id, CommandStatus.Failed, ex.Message);
        }
    }
}

public void Handle(ProcessPaymentCommand command)
{
    // Проверка, была ли команда уже выполнена
    if (_processedCommandIds.Contains(command.CommandId))
        return; // Команда уже была обработана, ничего не делаем
    
    // Обработка платежа
    _paymentService.Process(command.PaymentDetails);
    
    // Сохранение информации о выполненной команде
    _processedCommandIds.Add(command.CommandId);
}

// Выполнение команды
var version = await _commandProcessor.Process(new UpdateCustomerCommand { ... });
 
// Запрос с ожиданием определенной версии
var result = await _queryProcessor.ProcessWithVersion(new GetCustomerQuery { ... }, version);

MySolution/
├── Domain/ (домен-модель для команд)
├── Application/ (обработчики команд и запросов)
├── Infrastructure/ (реализация репозиториев, БД)
├── API/ (контроллеры API)
└── ReadModel/ (модели для запросов)

// Маркерные интерфейсы
public interface ICommand<TResult> { }
public interface IQuery<TResult> { }

public interface ICommandHandler<TCommand, TResult> 
    where TCommand : ICommand<TResult>
{
    TResult Handle(TCommand command);
}
 
public interface IQueryHandler<TQuery, TResult> 
    where TQuery : IQuery<TResult>
{
    TResult Handle(TQuery query);
}

public class EditCustomerInfoCommand : ICommand<Task<ValidationResult>>
{
    public EditCustomerInfoCommand(long id, string firstName, string lastName, int age)
    {
        Id = id;
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }
 
    public long Id { get; }
    public string FirstName { get; }
    public string LastName { get; }
    public int Age { get; }
}

public class EditCustomerInfoCommandHandler : 
    ICommandHandler<EditCustomerInfoCommand, Task<ValidationResult>>
{
    private readonly DbContextFactory _dbContextFactory;
 
    public EditCustomerInfoCommandHandler(DbContextFactory dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
    }
 
    public async Task<ValidationResult> Handle(EditCustomerInfoCommand command)
    {
        using var unitOfWork = new UnitOfWork(_dbContextFactory);
        var customerRepository = new CustomerRepository(unitOfWork);
 
        var customer = await customerRepository.GetByIdAsync(command.Id);
        if (customer == null) 
            return new ValidationResult("Клиент не найден!");
 
        customer.Update(
            command.FirstName,
            command.LastName,
            command.Age
        );
 
        customerRepository.Update(customer);
        await unitOfWork.CommitAsync();
 
        return ValidationResult.Success;
    }
}

public class GetAllCustomersQuery : IQuery<Task<IReadOnlyList<CustomerDto>>> 
{
    // Здесь могут быть параметры фильтрации, сортировки, пагинации
}
 
public class GetAllCustomersQueryHandler : 
    IQueryHandler<GetAllCustomersQuery, Task<IReadOnlyList<CustomerDto>>>
{
    private readonly string _connectionString;
 
    public GetAllCustomersQueryHandler(string connectionString)
    {
        _connectionString = connectionString;
    }
 
    public async Task<IReadOnlyList<CustomerDto>> Handle(GetAllCustomersQuery query)
    {
        using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();
        
        // Используем Dapper для прямого запроса к базе
        var customers = await connection.QueryAsync<CustomerDto>(@"
            SELECT c.Id, c.FirstName, c.LastName, c.Age, a.Street, a.City 
            FROM Customers c
            LEFT JOIN Addresses a ON a.CustomerId = c.Id AND a.IsPrimary = 1");
            
        return customers.ToList();
    }
}

public class MessageDispatcher
{
    private readonly IServiceProvider _serviceProvider;
 
    public MessageDispatcher(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
 
    public TResult Dispatch<TResult>(ICommand<TResult> command)
    {
        Type handlerType = typeof(ICommandHandler<,>).MakeGenericType(command.GetType(), typeof(TResult));
        dynamic handler = _serviceProvider.GetService(handlerType);
        return handler.Handle((dynamic)command);
    }
 
    public TResult Dispatch<TResult>(IQuery<TResult> query)
    {
        Type handlerType = typeof(IQueryHandler<,>).MakeGenericType(query.GetType(), typeof(TResult));
        dynamic handler = _serviceProvider.GetService(handlerType);
        return handler.Handle((dynamic)query);
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // Регистрация базовых сервисов
    services.AddSingleton<DbContextFactory>();
    services.AddSingleton<MessageDispatcher>();
    
    // Регистрация обработчиков команд
    services.AddTransient<ICommandHandler<EditCustomerInfoCommand, Task<ValidationResult>>, 
        EditCustomerInfoCommandHandler>();
    
    // Регистрация обработчиков запросов
    services.AddTransient<IQueryHandler<GetAllCustomersQuery, Task<IReadOnlyList<CustomerDto>>>, 
        GetAllCustomersQueryHandler>();
}

public static void AddHandlers(this IServiceCollection services)
{
    // Находим все типы, реализующие интерфейсы обработчиков
    var handlerTypes = typeof(ICommand<>).Assembly.GetTypes()
        .Where(t => !t.IsAbstract && !t.IsInterface)
        .Where(t => t.GetInterfaces().Any(i => i.IsGenericType && 
            (i.GetGenericTypeDefinition() == typeof(ICommandHandler<,>) || 
             i.GetGenericTypeDefinition() == typeof(IQueryHandler<,>))))
        .ToList();
 
    foreach (var handlerType in handlerTypes)
    {
        // Получаем информацию об интерфейсе обработчика
        var handlerInterface = handlerType.GetInterfaces().First(i => 
            i.IsGenericType && (
                i.GetGenericTypeDefinition() == typeof(ICommandHandler<,>) || 
                i.GetGenericTypeDefinition() == typeof(IQueryHandler<,>)));
            
        // Регистрируем обработчик
        services.AddTransient(handlerInterface, handlerType);
    }
}

[Route("api/[controller]")]
[ApiController]
public class CustomersController : ControllerBase
{
    private readonly MessageDispatcher _dispatcher;
 
    public CustomersController(MessageDispatcher dispatcher)
    {
        _dispatcher = dispatcher;
    }
 
    [HttpGet]
    public async Task<IActionResult> GetAll()
    {
        var query = new GetAllCustomersQuery();
        var result = await _dispatcher.Dispatch(query);
        return Ok(result);
    }
 
    [HttpPut("{id}")]
    public async Task<IActionResult> Update(long id, UpdateCustomerDto dto)
    {
        var command = new EditCustomerInfoCommand(
            id,
            dto.FirstName,
            dto.LastName,
            dto.Age);
 
        var result = await _dispatcher.Dispatch(command);
 
        if (!result.IsValid)
            return BadRequest(result.Errors);
 
        return NoContent();
    }
}

// Установите пакет: MediatR
// Install-Package MediatR
// Install-Package MediatR.Extensions.Microsoft.DependencyInjection
 
// Команда
public class UpdateCustomerCommand : IRequest<Result>
{
    public long Id { get; }
    public string FirstName { get; }
    public string LastName { get; }
    public int Age { get; }
 
    public UpdateCustomerCommand(long id, string firstName, string lastName, int age)
    {
        Id = id;
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }
}
 
// Обработчик команды
public class UpdateCustomerCommandHandler : IRequestHandler<UpdateCustomerCommand, Result>
{
    private readonly ICustomerRepository _repository;
 
    public UpdateCustomerCommandHandler(ICustomerRepository repository)
    {
        _repository = repository;
    }
 
    public async Task<Result> Handle(UpdateCustomerCommand request, CancellationToken cancellationToken)
    {
        var customer = await _repository.GetByIdAsync(request.Id);
        if (customer == null)
            return Result.Failure("Клиент не найден");
 
        customer.Update(request.FirstName, request.LastName, request.Age);
        await _repository.SaveChangesAsync();
        
        return Result.Success();
    }
}

services.AddMediatR(typeof(Startup).Assembly);

// Команда для резервирования места
public class ReserveSeatCommand : ICommand<ReservationResult>
{
    public Guid EventId { get; }
    public Guid SeatId { get; }
    public Guid UserId { get; }
    
    // Конструктор и другие свойства
}
 
// Обработчик команды
public class ReserveSeatCommandHandler : ICommandHandler<ReserveSeatCommand, ReservationResult>
{
    public ReservationResult Handle(ReserveSeatCommand command)
    {
        // 1. Проверяем доступность места (с оптимистичной блокировкой)
        // 2. Резервируем место для пользователя
        // 3. Генерируем событие о резервации
        // 4. Возвращаем результат
    }
}
 
// Запрос для просмотра доступных мест
public class GetAvailableSeatsQuery : IQuery<List<SeatDto>>
{
    public Guid EventId { get; }
}
 
// Обработчик запроса
public class GetAvailableSeatsQueryHandler : IQueryHandler<GetAvailableSeatsQuery, List<SeatDto>>
{
    public List<SeatDto> Handle(GetAvailableSeatsQuery query)
    {
        // Запрос к оптимизированной для чтения модели,
        // возможно кэшированной или денормализованной
    }
}

// Команда для перевода средств
public class TransferFundsCommand : ICommand<TransferResult>
{
    public Guid FromAccountId { get; }
    public Guid ToAccountId { get; }
    public decimal Amount { get; }
    public string Reference { get; }
}
 
// Запрос для проверки баланса
public class GetAccountBalanceQuery : IQuery<AccountBalanceDto>
{
    public Guid AccountId { get; }
}

public class GenerateSalesReportQuery : IQuery<SalesReportDto>
{
    public DateTime StartDate { get; }
    public DateTime EndDate { get; }
    public string[] ProductCategories { get; }
    public string[] Regions { get; }
}
 
public class GenerateSalesReportQueryHandler : IQueryHandler<GenerateSalesReportQuery, SalesReportDto>
{
    private readonly ISalesReportRepository _reportRepository;
    
    public SalesReportDto Handle(GenerateSalesReportQuery query)
    {
        // Использование оптимизированных SQL-запросов или материализованных представлений
        return _reportRepository.GenerateReport(query);
    }
}

// Событие, сгенерированное после обработки команды
public class OrderPlacedEvent : IEvent
{
    public Guid OrderId { get; }
    public Guid CustomerId { get; }
    public OrderItem[] Items { get; }
    public DateTime PlacedOn { get; }
}
 
// Обработчик события для обновления модели чтения
public class OrderPlacedEventHandler : IEventHandler<OrderPlacedEvent>
{
    private readonly IReadModelRepository _repository;
    
    public void Handle(OrderPlacedEvent @event)
    {
        // Обновление модели чтения
        // Возможно, обновление нескольких представлений для разных запросов
    }
}

public class LoggingCommandHandlerDecorator<TCommand, TResult> : ICommandHandler<TCommand, TResult>
    where TCommand : ICommand<TResult>
{
    private readonly ICommandHandler<TCommand, TResult> _decorated;
    private readonly ITelemetry _telemetry;
    
    public TResult Handle(TCommand command)
    {
        string commandName = typeof(TCommand).Name;
        
        _telemetry.TrackEvent($"Command:{commandName}", new Dictionary<string, string> {
            ["CommandData"] = JsonSerializer.Serialize(command)
        });
        
        var stopwatch = Stopwatch.StartNew();
        try
        {
            var result = _decorated.Handle(command);
            stopwatch.Stop();
            
            _telemetry.TrackMetric($"Command:{commandName}:ExecutionTime", stopwatch.ElapsedMilliseconds);
            return result;
        }
        catch (Exception ex)
        {
            _telemetry.TrackException(ex, new Dictionary<string, string> {
                ["CommandName"] = commandName
            });
            throw;
        }
    }
}

// Шаг 1: Выделяем команды и запросы из существующих методов сервиса
// Было:
public class ProductService
{
    public Product GetById(int id) { ... }
    public void UpdatePrice(int id, decimal price) { ... }
}
 
// Стало:
public class GetProductQuery : IQuery<Product>
{
    public int Id { get; set; }
}
 
public class UpdateProductPriceCommand : ICommand
{
    public int Id { get; set; }
    public decimal NewPrice { get; set; }
}

public class GetProductQueryHandler : IQueryHandler<GetProductQuery, Product>
{
    private readonly ProductService _legacyService;
    
    public Product Handle(GetProductQuery query)
    {
        return _legacyService.GetById(query.Id);
    }
}

public class ProductReadModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string CategoryName { get; set; }  // Денормализация
    public int StockCount { get; set; }       // Денормализация
    public double AverageRating { get; set; } // Предвычисление
}

public class SearchProductsQueryHandler : IQueryHandler<SearchProductsQuery, ProductSearchResult>
{
    private readonly ElasticClient _elasticClient;
    
    public ProductSearchResult Handle(SearchProductsQuery query)
    {
        var searchResponse = _elasticClient.Search<ProductReadModel>(s => s
            .Query(q => q
                .MultiMatch(mm => mm
                    .Fields(f => f.Field(p => p.Name).Field(p => p.Description))
                    .Query(query.SearchTerm)
                )
            )
            .Sort(so => so.Field(f => f.PopularityScore, SortOrder.Descending))
            .Size(query.PageSize)
            .Skip(query.PageSize * (query.Page - 1))
        );
        
        return new ProductSearchResult
        {
            Products = searchResponse.Documents.ToList(),
            TotalHits = searchResponse.Total
        };
    }
}

[Fact]
public void UpdatePriceCommand_ShouldUpdateProductPrice()
{
    // Arrange
    var repository = new Mock<IProductRepository>();
    var product = new Product { Id = 1, Price = 10m };
    repository.Setup(r => r.GetById(1)).Returns(product);
    
    var handler = new UpdateProductPriceCommandHandler(repository.Object);
    var command = new UpdateProductPriceCommand { Id = 1, NewPrice = 15m };
    
    // Act
    handler.Handle(command);
    
    // Assert
    repository.Verify(r => r.Save(It.Is<Product>(p => p.Price == 15m)), Times.Once);
}