CQRS и Event Sourcing на C#

public class CreateOrderCommand
{
    public Guid CustomerId { get; set; }
    public List<OrderItem> Items { get; set; }
    public string ShippingAddress { get; set; }
}
 
public class CreateOrderCommandHandler : ICommandHandler<CreateOrderCommand>
{
    private readonly IOrderRepository _repository;
    
    public CreateOrderCommandHandler(IOrderRepository repository)
    {
        _repository = repository;
    }
    
    public async Task Handle(CreateOrderCommand command)
    {
        var order = new Order(command.CustomerId, command.Items, command.ShippingAddress);
        await _repository.SaveAsync(order);
    }
}

public class GetOrderDetailsQuery
{
    public Guid OrderId { get; set; }
}
 
public class GetOrderDetailsQueryHandler : IQueryHandler<GetOrderDetailsQuery, OrderDetailsDto>
{
    private readonly IReadDbContext _readDb;
    
    public GetOrderDetailsQueryHandler(IReadDbContext readDb)
    {
        _readDb = readDb;
    }
    
    public async Task<OrderDetailsDto> Handle(GetOrderDetailsQuery query)
    {
        return await _readDb.OrderDetails
            .Where(o => o.Id == query.OrderId)
            .FirstOrDefaultAsync();
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // Регистрация обработчиков команд
    services.AddTransient<ICommandHandler<CreateOrderCommand>, CreateOrderCommandHandler>();
    services.AddTransient<ICommandHandler<CancelOrderCommand>, CancelOrderCommandHandler>();
    
    // Регистрация обработчиков запросов
    services.AddTransient<IQueryHandler<GetOrderDetailsQuery, OrderDetailsDto>, GetOrderDetailsQueryHandler>();
    services.AddTransient<IQueryHandler<GetCustomerOrdersQuery, List<OrderSummaryDto>>, GetCustomerOrdersQueryHandler>();
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMediatR(typeof(Startup).Assembly);
}

public class EventStore : IEventStore
{
    private readonly DbContext _dbContext;
    
    public EventStore(DbContext dbContext)
    {
        _dbContext = dbContext;
    }
    
    public async Task SaveEventsAsync(Guid aggregateId, IEnumerable<IDomainEvent> events, int expectedVersion)
    {
        var eventEntities = events.Select(e => new EventEntity
        {
            AggregateId = aggregateId,
            Data = JsonSerializer.Serialize(e),
            Type = e.GetType().AssemblyQualifiedName,
            Version = ++expectedVersion,
            Timestamp = DateTime.UtcNow
        }).ToList();
        
        await _dbContext.Events.AddRangeAsync(eventEntities);
        await _dbContext.SaveChangesAsync();
    }
    
    public async Task<IEnumerable<IDomainEvent>> GetEventsAsync(Guid aggregateId)
    {
        var events = await _dbContext.Events
            .Where(e => e.AggregateId == aggregateId)
            .OrderBy(e => e.Version)
            .ToListAsync();
            
        return events.Select(e => 
        {
            var type = Type.GetType(e.Type);
            return (IDomainEvent)JsonSerializer.Deserialize(e.Data, type);
        });
    }
}

public async Task<T> LoadAggregateAsync<T>(Guid aggregateId) where T : AggregateRoot, new()
{
    var snapshot = await GetLatestSnapshotAsync(aggregateId);
    var aggregate = new T();
    
    if (snapshot != null)
    {
        aggregate.LoadFromSnapshot(snapshot);
        var events = await _eventStore.GetEventsAsync(aggregateId, snapshot.Version + 1);
        aggregate.ApplyEvents(events);
    }
    else
    {
        var events = await _eventStore.GetEventsAsync(aggregateId);
        aggregate.ApplyEvents(events);
    }
    
    return aggregate;
}

public async Task SaveEventsAsync(Guid aggregateId, IEnumerable<IDomainEvent> events, int expectedVersion)
{
var dbVersion = await GetCurrentVersionAsync(aggregateId);
 
if (expectedVersion != -1 && dbVersion != expectedVersion)
{
    throw new ConcurrencyException($"Агрегат с ID {aggregateId} был изменен. Ожидаемая версия: {expectedVersion}, текущая: {dbVersion}");
}
 
// Остальной код сохранения событий...
}

public abstract class AggregateRoot
{
private readonly List<IDomainEvent> _uncommittedEvents = new();
 
public Guid Id { get; protected set; }
public int Version { get; private set; } = -1;
 
protected void ApplyEvent(IDomainEvent @event)
{
    // Метод применяет изменения к состоянию агрегата
    ((dynamic)this).Apply((dynamic)@event);
    
    // И сохраняет событие для последующей фиксации
    _uncommittedEvents.Add(@event);
}
 
public void ApplyEvents(IEnumerable<IDomainEvent> events)
{
    foreach (var @event in events)
    {
        // Применяем событие к состоянию
        ((dynamic)this).Apply((dynamic)@event);
        
        // Обновляем версию
        Version++;
    }
}
 
public IEnumerable<IDomainEvent> GetUncommittedEvents()
{
    return _uncommittedEvents;
}
 
public void ClearUncommittedEvents()
{
    _uncommittedEvents.Clear();
}
}

public async Task Handle(CreateOrderCommand command)
{
    // Создаем агрегат и применяем бизнес-логику
    var order = new Order(command.CustomerId);
    foreach (var item in command.Items)
    {
        order.AddItem(item.ProductId, item.Quantity, item.Price);
    }
    order.SetShippingAddress(command.ShippingAddress);
    
    // Сохраняем события в хранилище
    var events = order.GetUncommittedEvents();
    await _eventStore.SaveEventsAsync(order.Id, events, -1);
    
    // Публикуем события для обновления проекций
    foreach (var @event in events)
    {
        await _eventBus.PublishAsync(@event);
    }
}

public class RabbitMqEventBus : IEventBus
{
    private readonly IConnection _connection;
    private readonly IModel _channel;
    private readonly string _exchangeName = "domain_events";
 
    public RabbitMqEventBus(ConnectionFactory connectionFactory)
    {
        _connection = connectionFactory.CreateConnection();
        _channel = _connection.CreateModel();
        _channel.ExchangeDeclare(_exchangeName, ExchangeType.Fanout);
    }
 
    public Task PublishAsync<T>(T @event) where T : IDomainEvent
    {
        var eventType = @event.GetType().Name;
        var message = JsonSerializer.Serialize(@event);
        var body = Encoding.UTF8.GetBytes(message);
 
        _channel.BasicPublish(
            exchange: _exchangeName,
            routingKey: eventType,
            basicProperties: null,
            body: body);
 
        return Task.CompletedTask;
    }
}

public class OrderProcessSaga : 
    IHandleEvent<OrderCreated>,
    IHandleEvent<PaymentProcessed>,
    IHandleEvent<PaymentFailed>,
    IHandleEvent<InventoryReserved>,
    IHandleEvent<InventoryReservationFailed>
{
    private readonly ICommandBus _commandBus;
 
    public OrderProcessSaga(ICommandBus commandBus)
    {
        _commandBus = commandBus;
    }
 
    public async Task Handle(OrderCreated @event)
    {
        await _commandBus.SendAsync(new ProcessPaymentCommand
        {
            OrderId = @event.OrderId,
            Amount = @event.TotalAmount
        });
    }
 
    public async Task Handle(PaymentProcessed @event)
    {
        await _commandBus.SendAsync(new ReserveInventoryCommand
        {
            OrderId = @event.OrderId,
            Items = @event.Items
        });
    }
 
    public async Task Handle(PaymentFailed @event)
    {
        await _commandBus.SendAsync(new CancelOrderCommand
        {
            OrderId = @event.OrderId,
            Reason = "Платеж не прошел"
        });
    }
 
    public async Task Handle(InventoryReserved @event)
    {
        await _commandBus.SendAsync(new CompleteOrderCommand
        {
            OrderId = @event.OrderId
        });
    }
 
    public async Task Handle(InventoryReservationFailed @event)
    {
        await _commandBus.SendAsync(new RefundPaymentCommand
        {
            OrderId = @event.OrderId,
            Amount = @event.Amount
        });
        
        await _commandBus.SendAsync(new CancelOrderCommand
        {
            OrderId = @event.OrderId,
            Reason = "Товар отсутствует на складе"
        });
    }
}

public void ApplyChanges(Order order, int expectedVersion)
{
    // Проверяем версию перед сохранением
    if (order.Version != expectedVersion)
        throw new ConcurrencyException($"Ожидалась версия {expectedVersion}, но текущая версия {order.Version}");
 
    // Логика сохранения изменений
    var uncommittedEvents = order.GetUncommittedEvents();
    _eventStore.SaveEvents(order.Id, uncommittedEvents, expectedVersion);
    
    // Публикуем события
    foreach (var evt in uncommittedEvents)
        _eventPublisher.Publish(evt);
}

// Обработчик события, обновляющий проекцию для чтения
public class OrderCreatedProjection : IEventHandler<OrderCreated>
{
    private readonly IReadDbContext _readDb;
    
    public OrderCreatedProjection(IReadDbContext readDb)
    {
        _readDb = readDb;
    }
    
    public async Task Handle(OrderCreated @event)
    {
        // Создаем объект для проекции чтения
        var orderSummary = new OrderSummaryReadModel
        {
            Id = @event.OrderId,
            CustomerId = @event.CustomerId,
            TotalAmount = @event.TotalAmount,
            OrderDate = @event.Timestamp,
            Status = "Created"
        };
        
        await _readDb.OrderSummaries.AddAsync(orderSummary);
        await _readDb.SaveChangesAsync();
    }
}

[Test]
public void WhenAddingItemToOrder_ThenOrderItemAddedEventIsGenerated()
{
    // Arrange
    var order = new Order(Guid.NewGuid(), "customer@example.com");
    
    // Act
    order.AddItem("product-1", 2, 10.0m);
    
    // Assert
    var uncommittedEvents = order.GetUncommittedEvents();
    Assert.That(uncommittedEvents, Has.Exactly(1).Items);
    Assert.That(uncommittedEvents.First(), Is.TypeOf<OrderItemAdded>());
    
    var @event = (OrderItemAdded)uncommittedEvents.First();
    Assert.That(@event.ProductId, Is.EqualTo("product-1"));
    Assert.That(@event.Quantity, Is.EqualTo(2));
    Assert.That(@event.Price, Is.EqualTo(10.0m));
}

public async Task Handle(ProcessOrderCommand command)
{
    using var activity = _activitySource.StartActivity("ProcessOrder");
    activity?.SetTag("orderId", command.OrderId);
    
    try
    {
        // Логика обработки команды
        
        activity?.SetStatus(ActivityStatusCode.Ok);
    }
    catch (Exception ex)
    {
        activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
        throw;
    }
}

public async Task<T> LoadAggregate<T>(Guid id) where T : AggregateRoot, new()
{
    var snapshot = await _snapshotStore.GetLatestSnapshot<T>(id);
    var aggregate = new T();
    
    if (snapshot != null)
    {
        aggregate.LoadFromSnapshot(snapshot);
        var events = await _eventStore.GetEventsAfterVersion(id, snapshot.Version);
        aggregate.ApplyEvents(events);
    }
    else
    {
        var events = await _eventStore.GetAllEvents(id);
        aggregate.ApplyEvents(events);
    }
    
    return aggregate;
}

public class CachedOrderQueryService : IOrderQueryService
{
    private readonly IOrderQueryService _innerService;
    private readonly IMemoryCache _cache;
    private readonly IEventBus _eventBus;
    private readonly TimeSpan _defaultTtl = TimeSpan.FromMinutes(10);
 
    public CachedOrderQueryService(
        IOrderQueryService innerService,
        IMemoryCache cache,
        IEventBus eventBus)
    {
        _innerService = innerService;
        _cache = cache;
        _eventBus = eventBus;
        
        // Подписываемся на события, которые инвалидируют кэш
        _eventBus.Subscribe<OrderStatusChanged>(InvalidateOrderCache);
        _eventBus.Subscribe<OrderItemAdded>(InvalidateOrderCache);
    }
 
    public async Task<OrderDetailsDto> GetOrderDetailsAsync(Guid orderId)
    {
        var cacheKey = $"Order:{orderId}";
        
        if (!_cache.TryGetValue(cacheKey, out OrderDetailsDto result))
        {
            result = await _innerService.GetOrderDetailsAsync(orderId);
            _cache.Set(cacheKey, result, _defaultTtl);
        }
        
        return result;
    }
    
    private Task InvalidateOrderCache(OrderStatusChanged @event)
    {
        var cacheKey = $"Order:{@event.OrderId}";
        _cache.Remove(cacheKey);
        return Task.CompletedTask;
    }
    
    private Task InvalidateOrderCache(OrderItemAdded @event)
    {
        var cacheKey = $"Order:{@event.OrderId}";
        _cache.Remove(cacheKey);
        return Task.CompletedTask;
    }
}

public class EventUpcastingDecorator : IEventStore
{
    private readonly IEventStore _inner;
    private readonly Dictionary<Type, Func<object, object>> _upcasters;
 
    public EventUpcastingDecorator(IEventStore inner)
    {
        _inner = inner;
        _upcasters = new Dictionary<Type, Func<object, object>>
        {
            { typeof(OldOrderCreatedEvent), e => UpcastOrderCreatedEvent((OldOrderCreatedEvent)e) }
        };
    }
 
    public async Task<IEnumerable<IDomainEvent>> GetEventsAsync(Guid aggregateId)
    {
        var events = await _inner.GetEventsAsync(aggregateId);
        return events.Select(UpcastIfNeeded);
    }
 
    private IDomainEvent UpcastIfNeeded(IDomainEvent @event)
    {
        var eventType = @event.GetType();
        if (_upcasters.TryGetValue(eventType, out var upcaster))
        {
            return (IDomainEvent)upcaster(@event);
        }
        return @event;
    }
 
    private OrderCreatedEvent UpcastOrderCreatedEvent(OldOrderCreatedEvent old)
    {
        return new OrderCreatedEvent
        {
            OrderId = old.OrderId,
            CustomerId = old.CustomerId,
            TotalAmount = old.TotalAmount,
            Items = old.Items.Select(i => new OrderItemDto 
            {
                ProductId = i.ProductId,
                Quantity = i.Quantity,
                Price = i.Price,
                // Новое поле, которого не было в старой версии
                DiscountAmount = 0
            }).ToList(),
            Timestamp = old.Timestamp
        };
    }
    
    // Остальные методы интерфейса IEventStore...
}

[EventVersion("OrderCreated", 1)]
public class OrderCreatedEventV1 : IDomainEvent
{
    public Guid OrderId { get; set; }
    public Guid CustomerId { get; set; }
    // Поля версии 1
}
 
[EventVersion("OrderCreated", 2)]
public class OrderCreatedEventV2 : IDomainEvent
{
    public Guid OrderId { get; set; }
    public Guid CustomerId { get; set; }
    // Поля версии 1
    // + дополнительные поля версии 2
}

public async Task SaveEventsAsync(Guid aggregateId, IEnumerable<IDomainEvent> events, int expectedVersion)
{
    // Сохраняем события
    await _innerEventStore.SaveEventsAsync(aggregateId, events, expectedVersion);
    
    // Проверяем, нужно ли создать снэпшот
    var currentVersion = expectedVersion + events.Count();
    if (currentVersion % SnapshotFrequency == 0)
    {
        var aggregate = await _aggregateLoader.LoadAggregateAsync<T>(aggregateId);
        await _snapshotStore.SaveSnapshotAsync(aggregate);
    }
}

public async Task<IEnumerable<IDomainEvent>> GetEventsAsync(Guid aggregateId)
{
    var eventRecords = await _dbContext.Events
        .Where(e => e.AggregateId == aggregateId)
        .OrderBy(e => e.Version)
        .ToListAsync();
        
    return eventRecords.Select(record => 
    {
        // Используем MessagePack для десериализации
        return MessagePackSerializer.Deserialize(record.Data, 
            Type.GetType(record.EventType)) as IDomainEvent;
    });
}

public async Task Handle(IDomainEvent @event)
{
    var projectionTasks = _projections
        .Where(p => p.CanHandle(@event.GetType()))
        .Select(p => p.HandleAsync(@event));
        
    await Task.WhenAll(projectionTasks);
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Startup).Assembly));
}

public record CreateOrderCommand(
    Guid CustomerId,
    List<OrderItemDto> Items,
    string ShippingAddress) : IRequest;

public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand>
{
    private readonly IOrderRepository _repository;
    private readonly IEventStore _eventStore;
 
    public CreateOrderCommandHandler(IOrderRepository repository, IEventStore eventStore)
    {
        _repository = repository;
        _eventStore = eventStore;
    }
 
    public async Task Handle(CreateOrderCommand request, CancellationToken cancellationToken)
    {
        var order = new Order(
            Guid.NewGuid(),
            request.CustomerId,
            request.ShippingAddress);
            
        foreach (var item in request.Items)
        {
            order.AddItem(item.ProductId, item.Quantity, item.Price);
        }
 
        await _repository.SaveAsync(order, cancellationToken);
        
        // Сохраняем события
        var events = order.GetUncommittedEvents();
        await _eventStore.SaveEventsAsync(order.Id, events, -1, cancellationToken);
    }
}

public record GetOrderDetailsQuery(Guid OrderId) : IRequest<OrderDetailsDto>;
 
public class OrderDetailsDto
{
    public Guid Id { get; init; }
    public string CustomerName { get; init; }
    public decimal TotalAmount { get; init; }
    public string Status { get; init; }
    public List<OrderItemDto> Items { get; init; }
    // Другие поля, необходимые для UI
}

public class GetOrderDetailsQueryHandler : IRequestHandler<GetOrderDetailsQuery, OrderDetailsDto>
{
    private readonly IReadDbContext _readDb;
 
    public GetOrderDetailsQueryHandler(IReadDbContext readDb)
    {
        _readDb = readDb;
    }
 
    public async Task<OrderDetailsDto> Handle(GetOrderDetailsQuery request, CancellationToken cancellationToken)
    {
        return await _readDb.OrderDetails
            .AsNoTracking() // Важно для производительности!
            .Where(o => o.Id == request.OrderId)
            .Select(o => new OrderDetailsDto
            {
                Id = o.Id,
                CustomerName = o.CustomerName,
                TotalAmount = o.TotalAmount,
                Status = o.Status,
                Items = o.Items.Select(i => new OrderItemDto
                {
                    ProductId = i.ProductId,
                    ProductName = i.ProductName,
                    Quantity = i.Quantity,
                    Price = i.Price
                }).ToList()
            })
            .FirstOrDefaultAsync(cancellationToken) 
            ?? throw new OrderNotFoundException(request.OrderId);
    }
}

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();
    }
}

services.AddMediatR(cfg => {
    cfg.RegisterServicesFromAssembly(typeof(Startup).Assembly);
    cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
});

public class OrderConfirmationEmailSender : IEventHandler<OrderConfirmed>
{
    private readonly IEmailService _emailService;
    private readonly ITemplateEngine _templateEngine;
 
    public OrderConfirmationEmailSender(IEmailService emailService, ITemplateEngine templateEngine)
    {
        _emailService = emailService;
        _templateEngine = templateEngine;
    }
 
    public async Task Handle(OrderConfirmed @event, CancellationToken cancellationToken)
    {
        var emailTemplate = await _templateEngine.RenderAsync(
            "OrderConfirmation",
            new { OrderId = @event.OrderId, CustomerEmail = @event.CustomerEmail });
            
        await _emailService.SendEmailAsync(
            @event.CustomerEmail,
            "Ваш заказ подтвержден",
            emailTemplate,
            cancellationToken);
    }
}

public class LargeTransactionNotifier : IEventHandler<TransactionCompleted>
{
    private readonly ITelegramService _telegramService;
    private readonly decimal _largeTransactionThreshold;
    
    public LargeTransactionNotifier(ITelegramService telegramService, IConfiguration config)
    {
        _telegramService = telegramService;
        _largeTransactionThreshold = config.GetValue<decimal>("Notifications:LargeTransactionThreshold");
    }
    
    public async Task Handle(TransactionCompleted @event, CancellationToken cancellationToken)
    {
        if (@event.Amount < _largeTransactionThreshold)
            return;
            
        // Проверяем, рабочее ли сейчас время
        var now = DateTime.Now;
        var isWorkingHours = now.Hour >= 9 && now.Hour < 18 && now.DayOfWeek != DayOfWeek.Saturday && now.DayOfWeek != DayOfWeek.Sunday;
        
        if (!isWorkingHours)
            return;
            
        await _telegramService.SendMessageAsync(
            @event.UserId,
            $"Уведомление: выполнена транзакция на сумму {@event.Amount} руб.",
            cancellationToken);
    }
}

public class ElasticsearchEventSink : IEventHandler<IDomainEvent>
{
    private readonly IElasticClient _elasticClient;
    private readonly ILogger<ElasticsearchEventSink> _logger;
    
    public ElasticsearchEventSink(IElasticClient elasticClient, ILogger<ElasticsearchEventSink> logger)
    {
        _elasticClient = elasticClient;
        _logger = logger;
    }
    
    public async Task Handle(IDomainEvent @event, CancellationToken cancellationToken)
    {
        try
        {
            // Обогащаем событие дополнительными метаданными
            var eventWrapper = new EventWrapper
            {
                EventId = Guid.NewGuid(),
                EventType = @event.GetType().Name,
                Timestamp = DateTime.UtcNow,
                Data = @event
            };
            
            // Индекс именуется по типу события и дате
            var indexName = $"events-{@event.GetType().Name.ToLower()}-{DateTime.UtcNow:yyyy-MM}";
            
            var response = await _elasticClient.IndexDocumentAsync(eventWrapper, cancellationToken);
            
            if (!response.IsValid)
            {
                _logger.LogError("Ошибка при индексации события: {Error}", response.DebugInformation);
            }
        }
        catch (Exception ex)
        {
            // Важно: ошибки в аналитике не должны влиять на основной поток выполнения
            _logger.LogError(ex, "Ошибка при отправке события в Elasticsearch");
        }
    }
}

public async Task Handle(OrderConfirmed @event, CancellationToken cancellationToken)
{
    try
    {
        var email = ComposeEmail(@event);
        await _emailService.SendAsync(email, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Не удалось отправить уведомление о заказе {OrderId}", @event.OrderId);
        
        // Сохраняем задачу для повторной попытки
        await _retryTaskRepository.SaveAsync(new RetryTask
        {
            Id = Guid.NewGuid(),
            Type = "SendOrderConfirmationEmail",
            Data = JsonSerializer.Serialize(new { OrderId = @event.OrderId, CustomerEmail = @event.CustomerEmail }),
            CreatedAt = DateTime.UtcNow,
            RetryCount = 0,
            NextRetryAt = DateTime.UtcNow.AddMinutes(5)
        }, cancellationToken);
    }
}

Solution 'EShop'
├── Domain
│   ├── Aggregates
│   ├── Commands
│   ├── Events
│   └── Exceptions
├── Application
│   ├── CommandHandlers
│   ├── QueryHandlers
│   ├── EventHandlers
│   └── Services
├── Infrastructure
│   ├── Persistence
│   ├── EventStore
│   ├── ReadModels
│   └── ExternalServices
└── API
    ├── Controllers
    ├── Filters
    └── Startup

public class HybridEventStore : IEventStore
{
    private readonly SqlEventStore _sqlStore;
    private readonly EventStoreDb _eventStoreDb;
    private readonly ILogger<HybridEventStore> _logger;
 
    public HybridEventStore(
        SqlEventStore sqlStore,
        EventStoreDb eventStoreDb,
        ILogger<HybridEventStore> logger)
    {
        _sqlStore = sqlStore;
        _eventStoreDb = eventStoreDb;
        _logger = logger;
    }
 
    public async Task SaveEventsAsync(Guid aggregateId, IEnumerable<IDomainEvent> events, int expectedVersion)
    {
        // Сначала сохраняем в SQL для атомарности
        await _sqlStore.SaveEventsAsync(aggregateId, events, expectedVersion);
 
        try
        {
            // Затем в EventStoreDb для эффективного чтения
            await _eventStoreDb.SaveEventsAsync(aggregateId, events, expectedVersion);
        }
        catch (Exception ex)
        {
            // Если не удалось сохранить в EventStoreDb, логируем ошибку, 
            // но не фейлим операцию, т.к. данные уже сохранены в SQL
            _logger.LogError(ex, "Не удалось сохранить события в EventStoreDb");
        }
    }
 
    public async Task<IEnumerable<IDomainEvent>> GetEventsAsync(Guid aggregateId)
    {
        try
        {
            // Сначала пытаемся получить из EventStoreDb
            return await _eventStoreDb.GetEventsAsync(aggregateId);
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "Не удалось получить события из EventStoreDb, пробуем из SQL");
            // Если не получилось, берем из SQL
            return await _sqlStore.GetEventsAsync(aggregateId);
        }
    }
}

public class DapperOrderQueries : IOrderQueries
{
    private readonly IDbConnection _connection;
 
    public DapperOrderQueries(string connectionString)
    {
        _connection = new SqlConnection(connectionString);
    }
 
    public async Task<OrderDetailsDto> GetOrderDetailsAsync(Guid orderId)
    {
        var sql = @"
            SELECT o.Id, o.CustomerName, o.TotalAmount, o.Status,
                   i.Id as ItemId, i.ProductName, i.Quantity, i.Price
            FROM Orders o
            LEFT JOIN OrderItems i ON o.Id = i.OrderId
            WHERE o.Id = @OrderId";
 
        OrderDetailsDto order = null;
        var items = new List<OrderItemDto>();
 
        await _connection.QueryAsync<OrderDetailsDto, OrderItemDto, OrderDetailsDto>(
            sql,
            (o, i) => {
                if (order == null)
                    order = o;
                
                if (i != null)
                    items.Add(i);
                
                return order;
            },
            new { OrderId = orderId },
            splitOn: "ItemId");
 
        if (order != null)
            order.Items = items;
 
        return order;
    }
}

public class OrderProjection : 
    IEventHandler<OrderCreated>,
    IEventHandler<OrderItemAdded>,
    IEventHandler<OrderConfirmed>
{
    private readonly IReadDbContext _readDb;
 
    public OrderProjection(IReadDbContext readDb)
    {
        _readDb = readDb;
    }
 
    public async Task Handle(OrderCreated @event, CancellationToken cancellationToken)
    {
        var orderReadModel = new OrderReadModel
        {
            Id = @event.OrderId,
            CustomerId = @event.CustomerId,
            CustomerName = @event.CustomerName,
            TotalAmount = 0, // Начальная сумма
            Status = "Created",
            CreatedAt = @event.Timestamp
        };
        
        await _readDb.Orders.AddAsync(orderReadModel, cancellationToken);
        await _readDb.SaveChangesAsync(cancellationToken);
    }
 
    public async Task Handle(OrderItemAdded @event, CancellationToken cancellationToken)
    {
        var order = await _readDb.Orders.FindAsync(new object[] { @event.OrderId }, cancellationToken);
        if (order == null) return; // Защита от отсутствия проекции
        
        var itemReadModel = new OrderItemReadModel
        {
            Id = Guid.NewGuid(),
            OrderId = @event.OrderId,
            ProductId = @event.ProductId,
            ProductName = @event.ProductName,
            Quantity = @event.Quantity,
            Price = @event.Price
        };
        
        await _readDb.OrderItems.AddAsync(itemReadModel, cancellationToken);
        
        // Обновляем общую сумму заказа
        order.TotalAmount += @event.Price * @event.Quantity;
        
        await _readDb.SaveChangesAsync(cancellationToken);
    }
 
    public async Task Handle(OrderConfirmed @event, CancellationToken cancellationToken)
    {
        var order = await _readDb.Orders.FindAsync(new object[] { @event.OrderId }, cancellationToken);
        if (order == null) return;
        
        order.Status = "Confirmed";
        order.ConfirmedAt = @event.Timestamp;
        
        await _readDb.SaveChangesAsync(cancellationToken);
    }
}

[ApiController]
[Route("api/orders")]
public class OrdersController : ControllerBase
{
    private readonly IMediator _mediator;
 
    public OrdersController(IMediator mediator)
    {
        _mediator = mediator;
    }
 
    [HttpPost]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderCommand command)
    {
        var orderId = await _mediator.Send(command);
        return CreatedAtAction(nameof(GetOrder), new { id = orderId }, null);
    }
 
    [HttpGet("{id}")]
    public async Task<ActionResult<OrderDetailsDto>> GetOrder(Guid id)
    {
        var query = new GetOrderDetailsQuery(id);
        var result = await _mediator.Send(query);
        return result;
    }
}