Что такое CQRS и как это реализовать на C# с MediatR

public class CreateUserCommand : ICommand
{
    public string Username { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
}

public class GetUserByIdQuery : IQuery<UserDto>
{
    public int UserId { get; set; }
}
 
public class UserDto
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
}

public class CreateUserCommandHandler : ICommandHandler<CreateUserCommand>
{
    private readonly IUserRepository _repository;
    
    public CreateUserCommandHandler(IUserRepository repository)
    {
        _repository = repository;
    }
    
    public async Task Handle(CreateUserCommand command)
    {
        var user = new User
        {
            Username = command.Username,
            Email = command.Email,
            PasswordHash = HashPassword(command.Password)
        };
        
        await _repository.CreateUser(user);
    }
}

public class GetUserByIdQueryHandler : IQueryHandler<GetUserByIdQuery, UserDto>
{
    private readonly IUserReadRepository _readRepository;
    
    public GetUserByIdQueryHandler(IUserReadRepository readRepository)
    {
        _readRepository = readRepository;
    }
    
    public async Task<UserDto> Handle(GetUserByIdQuery query)
    {
        return await _readRepository.GetUserById(query.UserId);
    }
}

public class OrderCreatedEventHandler : IEventHandler<OrderCreatedEvent>
{
    private readonly IReadModelUpdateService _updateService;
    
    public OrderCreatedEventHandler(IReadModelUpdateService updateService)
    {
        _updateService = updateService;
    }
    
    public async Task Handle(OrderCreatedEvent @event)
    {
        var readModel = new OrderReadModel
        {
            OrderId = @event.OrderId,
            CustomerName = @event.CustomerName,
            TotalAmount = @event.TotalAmount,
            Status = "Created"
        };
        
        await _updateService.UpdateReadModel(readModel);
    }
}

public class UpdateProductPriceCommand : ICommand
{
    public UpdateProductPriceCommand(Guid productId, decimal newPrice)
    {
        ProductId = productId;
        NewPrice = newPrice;
    }
 
    public Guid ProductId { get; private set; }
    public decimal NewPrice { get; private set; }
}

public class UpdateProductPriceCommandHandler : ICommandHandler<UpdateProductPriceCommand>
{
    private readonly IProductRepository _repository;
    private readonly IValidationService _validationService;
 
    public UpdateProductPriceCommandHandler(
        IProductRepository repository,
        IValidationService validationService)
    {
        _repository = repository;
        _validationService = validationService;
    }
 
    public async Task Handle(UpdateProductPriceCommand command)
    {
        await _validationService.ValidatePrice(command.NewPrice);
        var product = await _repository.GetById(command.ProductId);
        product.UpdatePrice(command.NewPrice);
        await _repository.SaveChanges();
    }
}

public class GetProductDetailsQuery : IQuery<ProductDetailsDto>
{
    public GetProductDetailsQuery(Guid productId, string cultureName)
    {
        ProductId = productId;
        CultureName = cultureName;
    }
 
    public Guid ProductId { get; private set; }
    public string CultureName { get; private set; }
}

public class GetProductDetailsQueryHandler : IQueryHandler<GetProductDetailsQuery, ProductDetailsDto>
{
    private readonly IProductReadRepository _readRepository;
    private readonly ICultureService _cultureService;
 
    public GetProductDetailsQueryHandler(
        IProductReadRepository readRepository,
        ICultureService cultureService)
    {
        _readRepository = readRepository;
        _cultureService = cultureService;
    }
 
    public async Task<ProductDetailsDto> Handle(GetProductDetailsQuery query)
    {
        var culture = await _cultureService.GetCulture(query.CultureName);
        return await _readRepository.GetProductDetails(query.ProductId, culture);
    }
}

// Модель записи
public class Product
{
    public Guid Id { get; private set; }
    public string Name { get; private set; }
    public decimal Price { get; private set; }
    public List<PriceHistory> PriceHistory { get; private set; }
 
    public void UpdatePrice(decimal newPrice)
    {
        PriceHistory.Add(new PriceHistory(Price, DateTime.UtcNow));
        Price = newPrice;
    }
}
 
// Модель чтения
public class ProductDetailsDto
{
    public Guid Id { get; set; }
    public string LocalizedName { get; set; }
    public decimal CurrentPrice { get; set; }
    public decimal PreviousPrice { get; set; }
    public string CurrencySymbol { get; set; }
}

public class ProductPriceUpdatedEvent : IEvent
{
    public Guid ProductId { get; private set; }
    public decimal OldPrice { get; private set; }
    public decimal NewPrice { get; private set; }
    public DateTime UpdatedAt { get; private set; }
 
    public ProductPriceUpdatedEvent(Guid productId, decimal oldPrice, decimal newPrice)
    {
        ProductId = productId;
        OldPrice = oldPrice;
        NewPrice = newPrice;
        UpdatedAt = DateTime.UtcNow;
    }
}

public class ProductPriceUpdatedEventHandler : IEventHandler<ProductPriceUpdatedEvent>
{
    private readonly IReadModelUpdater _readModelUpdater;
    private readonly ICacheInvalidator _cacheInvalidator;
 
    public ProductPriceUpdatedEventHandler(
        IReadModelUpdater readModelUpdater,
        ICacheInvalidator cacheInvalidator)
    {
        _readModelUpdater = readModelUpdater;
        _cacheInvalidator = cacheInvalidator;
    }
 
    public async Task Handle(ProductPriceUpdatedEvent @event)
    {
        await _readModelUpdater.UpdateProductPrice(@event.ProductId, @event.NewPrice);
        await _cacheInvalidator.InvalidateProductCache(@event.ProductId);
    }
}

public class UpdateProductPriceCommandValidator : IValidator<UpdateProductPriceCommand>
{
    public Task<ValidationResult> Validate(UpdateProductPriceCommand command)
    {
        var result = new ValidationResult();
        
        if (command.NewPrice <= 0)
        {
            result.AddError("Price must be greater than zero");
        }
        
        if (command.ProductId == Guid.Empty)
        {
            result.AddError("Invalid product identifier");
        }
        
        return Task.FromResult(result);
    }
}

public interface IProductReadRepository
{
    Task<ProductDetailsDto> GetProductDetails(Guid productId, CultureInfo culture);
    Task<IEnumerable<ProductListItemDto>> GetProductList(ProductFilterCriteria criteria);
}
 
public interface IProductWriteRepository
{
    Task<Product> GetById(Guid productId);
    Task Save(Product product);
    Task Delete(Guid productId);
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));
    services.AddScoped(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
    services.AddScoped(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
}

public class CreateProductCommand : IRequest<Guid>
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Description { get; set; }
    public string Category { get; set; }
}
 
public class CreateProductCommandHandler : IRequestHandler<CreateProductCommand, Guid>
{
    private readonly IProductRepository _repository;
    
    public CreateProductCommandHandler(IProductRepository repository)
    {
        _repository = repository;
    }
    
    public async Task<Guid> Handle(CreateProductCommand request, CancellationToken cancellationToken)
    {
        var product = new Product
        {
            Name = request.Name,
            Price = request.Price,
            Description = request.Description,
            Category = request.Category
        };
        
        await _repository.CreateProduct(product);
        return product.Id;
    }
}

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 ProductCreatedNotification : INotification
{
    public Guid ProductId { get; }
    public string ProductName { get; }
    
    public ProductCreatedNotification(Guid productId, string productName)
    {
        ProductId = productId;
        ProductName = productName;
    }
}
 
public class EmailNotificationHandler : INotificationHandler<ProductCreatedNotification>
{
    private readonly IEmailService _emailService;
    
    public EmailNotificationHandler(IEmailService emailService)
    {
        _emailService = emailService;
    }
    
    public async Task Handle(ProductCreatedNotification notification, CancellationToken cancellationToken)
    {
        await _emailService.SendProductCreatedNotification(notification.ProductId, notification.ProductName);
    }
}

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IMediator _mediator;
    
    public ProductsController(IMediator mediator)
    {
        _mediator = mediator;
    }
    
    [HttpPost]
    public async Task<ActionResult<Guid>> CreateProduct([FromBody] CreateProductCommand command)
    {
        var productId = await _mediator.Send(command);
        return CreatedAtAction(nameof(GetProduct), new { id = productId }, productId);
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<ProductDto>> GetProduct(Guid id)
    {
        var query = new GetProductByIdQuery(id);
        var result = await _mediator.Send(query);
        return Ok(result);
    }
}

public abstract class Entity
{
    public Guid Id { get; protected set; }
    private List<IDomainEvent> _domainEvents = new();
    
    public IReadOnlyCollection<IDomainEvent> DomainEvents => _domainEvents.AsReadOnly();
    
    protected void AddDomainEvent(IDomainEvent domainEvent)
    {
        _domainEvents.Add(domainEvent);
    }
    
    public void ClearDomainEvents()
    {
        _domainEvents.Clear();
    }
}
 
public class Order : Entity
{
    public string CustomerName { get; private set; }
    public decimal TotalAmount { get; private set; }
    public OrderStatus Status { get; private set; }
    public List<OrderItem> Items { get; private set; }
    
    public void AddItem(Product product, int quantity)
    {
        var item = new OrderItem(product, quantity);
        Items.Add(item);
        TotalAmount += item.SubTotal;
        
        AddDomainEvent(new OrderItemAddedEvent(this.Id, product.Id, quantity));
    }
}

public interface IUnitOfWork
{
    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
    Task BeginTransactionAsync();
    Task CommitTransactionAsync();
    Task RollbackTransactionAsync();
}
 
public interface IRepository<T> where T : Entity
{
    Task<T> GetByIdAsync(Guid id);
    Task<IEnumerable<T>> GetAllAsync();
    Task AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(T entity);
}

public class CreateOrderCommand : IRequest<Guid>
{
    public string CustomerName { get; set; }
    public List<OrderItemDto> Items { get; set; }
}
 
public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, Guid>
{
    private readonly IOrderRepository _orderRepository;
    private readonly IProductRepository _productRepository;
    private readonly IUnitOfWork _unitOfWork;
    
    public CreateOrderCommandHandler(
        IOrderRepository orderRepository,
        IProductRepository productRepository,
        IUnitOfWork unitOfWork)
    {
        _orderRepository = orderRepository;
        _productRepository = productRepository;
        _unitOfWork = unitOfWork;
    }
    
    public async Task<Guid> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
    {
        var order = new Order(request.CustomerName);
        
        foreach (var item in request.Items)
        {
            var product = await _productRepository.GetByIdAsync(item.ProductId);
            order.AddItem(product, item.Quantity);
        }
        
        await _orderRepository.AddAsync(order);
        await _unitOfWork.SaveChangesAsync(cancellationToken);
        
        return order.Id;
    }
}

public class GetOrderDetailsQuery : IRequest<OrderDetailsDto>
{
    public Guid OrderId { get; set; }
}
 
public class GetOrderDetailsQueryHandler : IRequestHandler<GetOrderDetailsQuery, OrderDetailsDto>
{
    private readonly IOrderReadRepository _orderReadRepository;
    
    public GetOrderDetailsQueryHandler(IOrderReadRepository orderReadRepository)
    {
        _orderReadRepository = orderReadRepository;
    }
    
    public async Task<OrderDetailsDto> Handle(GetOrderDetailsQuery request, CancellationToken cancellationToken)
    {
        return await _orderReadRepository.GetOrderDetailsAsync(request.OrderId);
    }
}

public class CreateOrderCommandValidator : AbstractValidator<CreateOrderCommand>
{
    public CreateOrderCommandValidator()
    {
        RuleFor(x => x.CustomerName)
            .NotEmpty().WithMessage("Customer name is required")
            .MaximumLength(100).WithMessage("Customer name must not exceed 100 characters");
        
        RuleFor(x => x.Items)
            .NotEmpty().WithMessage("Order must contain at least one item");
        
        RuleForEach(x => x.Items).SetValidator(new OrderItemDtoValidator());
    }
}
 
public class OrderNotFoundException : Exception
{
    public OrderNotFoundException(Guid orderId)
        : base($"Order with ID {orderId} was not found.")
    {
    }
}

public class OrderRepository : IOrderRepository
{
    private readonly ApplicationDbContext _context;
    
    public OrderRepository(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public async Task<Order> GetByIdAsync(Guid id)
    {
        var order = await _context.Orders
            .Include(o => o.Items)
            .FirstOrDefaultAsync(o => o.Id == id);
            
        if (order == null)
            throw new OrderNotFoundException(id);
            
        return order;
    }
    
    public async Task AddAsync(Order order)
    {
        await _context.Orders.AddAsync(order);
    }
}

public class OrderCreatedDomainEventHandler : INotificationHandler<OrderCreatedDomainEvent>
{
    private readonly IEmailService _emailService;
    private readonly ILogger<OrderCreatedDomainEventHandler> _logger;
    
    public OrderCreatedDomainEventHandler(
        IEmailService emailService,
        ILogger<OrderCreatedDomainEventHandler> logger)
    {
        _emailService = emailService;
        _logger = logger;
    }
    
    public async Task Handle(OrderCreatedDomainEvent notification, CancellationToken cancellationToken)
    {
        try
        {
            await _emailService.SendOrderConfirmationEmail(
                notification.OrderId,
                notification.CustomerEmail);
                
            _logger.LogInformation(
                "Order confirmation email sent for order {OrderId}",
                notification.OrderId);
        }
        catch (Exception ex)
        {
            _logger.LogError(
                ex,
                "Failed to send order confirmation email for order {OrderId}",
                notification.OrderId);
        }
    }
}

public class CreateOrderCommand : IRequest<Guid>
{
    public List<OrderItemDto> Items { get; set; }
    public DeliveryDetails DeliveryDetails { get; set; }
    public PaymentInfo PaymentInfo { get; set; }
}
 
public class GetProductCatalogQuery : IRequest<PaginatedResult<ProductDto>>
{
    public ProductFilter Filter { get; set; }
    public int Page { get; set; }
    public int PageSize { get; set; }
}

public class TransferMoneyCommand : IRequest<TransactionResult>
{
    public Guid FromAccountId { get; set; }
    public Guid ToAccountId { get; set; }
    public decimal Amount { get; set; }
    public string Currency { get; set; }
}
 
public class GetAccountBalanceQuery : IRequest<AccountBalanceDto>
{
    public Guid AccountId { get; set; }
    public bool IncludeTransactionHistory { get; set; }
}

public class PublishArticleCommand : IRequest<PublishResult>
{
    public Guid ArticleId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public List<string> Tags { get; set; }
    public PublishingSettings Settings { get; set; }
}
 
public class GetArticlesByTagQuery : IRequest<List<ArticlePreviewDto>>
{
    public string Tag { get; set; }
    public ArticleSortingOptions SortBy { get; set; }
    public bool IncludeUnpublished { get; set; }
}

public class UpdateShipmentStatusCommand : IRequest<Unit>
{
    public Guid ShipmentId { get; set; }
    public ShipmentStatus NewStatus { get; set; }
    public GeoLocation CurrentLocation { get; set; }
    public string StatusDescription { get; set; }
}
 
public class GetShipmentTrackingQuery : IRequest<ShipmentTrackingDto>
{
    public string TrackingNumber { get; set; }
    public bool IncludeFullHistory { get; set; }
}

public class CreateReservationCommand : IRequest<ReservationResult>
{
    public Guid ResourceId { get; set; }
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
    public ReservationDetails Details { get; set; }
}
 
public class CheckResourceAvailabilityQuery : IRequest<AvailabilityInfo>
{
    public Guid ResourceId { get; set; }
    public DateTimeRange TimeRange { get; set; }
    public List<ResourceRequirement> Requirements { get; set; }
}

public class ReservationValidationBehavior<TRequest, TResponse>
    : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private readonly IAvailabilityChecker _availabilityChecker;
    
    public ReservationValidationBehavior(IAvailabilityChecker availabilityChecker)
    {
        _availabilityChecker = availabilityChecker;
    }
    
    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken)
    {
        if (request is CreateReservationCommand reservationCommand)
        {
            var isAvailable = await _availabilityChecker.CheckAvailability(
                reservationCommand.ResourceId,
                reservationCommand.StartTime,
                reservationCommand.EndTime);
                
            if (!isAvailable)
                throw new ResourceNotAvailableException(reservationCommand.ResourceId);
        }
        
        return await next();
    }
}

public class AccountBalanceQueryHandler : IRequestHandler<GetAccountBalanceQuery, AccountBalanceDto>
{
    private readonly IAccountReadRepository _repository;
    private readonly ICacheService _cacheService;
    
    public async Task<AccountBalanceDto> Handle(GetAccountBalanceQuery request, CancellationToken cancellationToken)
    {
        var cacheKey = $"account_balance_{request.AccountId}";
        var cachedBalance = await _cacheService.GetAsync<AccountBalanceDto>(cacheKey);
        
        if (cachedBalance != null)
            return cachedBalance;
            
        var balance = await _repository.GetBalanceAsync(request.AccountId);
        await _cacheService.SetAsync(cacheKey, balance, TimeSpan.FromMinutes(5));
        
        return balance;
    }
}

public class ArticlePublishedEventHandler : INotificationHandler<ArticlePublishedEvent>
{
    private readonly ISearchIndexService _searchIndex;
    private readonly ICacheInvalidator _cacheInvalidator;
    
    public async Task Handle(ArticlePublishedEvent notification, CancellationToken cancellationToken)
    {
        await _searchIndex.IndexArticle(notification.ArticleId);
        await _cacheInvalidator.InvalidateArticleCache(notification.ArticleId);
    }
}

public class OptimizeRouteCommandHandler : IRequestHandler<OptimizeRouteCommand, OptimizedRouteResult>
{
    private readonly IRouteOptimizationService _optimizationService;
    private readonly IShipmentRepository _shipmentRepository;
    
    public async Task<OptimizedRouteResult> Handle(OptimizeRouteCommand request, CancellationToken cancellationToken)
    {
        var shipments = await _shipmentRepository.GetActiveShipments();
        var optimizedRoute = await _optimizationService.OptimizeRoute(
            shipments,
            request.VehicleCapacity,
            request.TimeConstraints);
            
        return new OptimizedRouteResult
        {
            Route = optimizedRoute,
            EstimatedTime = optimizedRoute.CalculateEstimatedTime(),
            FuelEfficiency = optimizedRoute.CalculateFuelEfficiency()
        };
    }
}

public class TransactionalBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private readonly IUnitOfWork _unitOfWork;
    
    public async Task<TResponse> Handle(
        TRequest request,
        RequestHandlerDelegate<TResponse> next,
        CancellationToken cancellationToken)
    {
        try
        {
            await _unitOfWork.BeginTransactionAsync();
            var response = await next();
            await _unitOfWork.CommitTransactionAsync();
            return response;
        }
        catch
        {
            await _unitOfWork.RollbackTransactionAsync();
            throw;
        }
    }
}