Паттерн SAGA и распределённые транзакции в микросервисной архитектуре

using (var transaction = new TransactionScope())
{
    var stockService = new StockService();
    var paymentService = new PaymentService();
    var orderService = new OrderService();
    
    // Проверка и резервирование товара
    stockService.ReserveItem(itemId, quantity);
    
    // Проверка и обработка платежа
    paymentService.ProcessPayment(userId, amount);
    
    // Создание заказа
    orderService.CreateOrder(userId, itemId, quantity);
    
    transaction.Complete();
}

// Сервис пользователей имеет полную информацию о пользователе
public class User
{
    public Guid Id { get; set; }
    public string Email { get; set; }
    public string Name { get; set; }
    public Address Address { get; set; }
    // ...
}
 
// Сервис заказов хранит необходимые данные о пользователе
public class OrderCustomer
{
    public Guid UserId { get; set; }
    public string Email { get; set; }
    public string Name { get; set; }
    // Минимально необходимая информация
}

// Пример публикации события в сервисе заказов
public async Task CreateOrder(CreateOrderCommand command)
{
    var order = new Order
    {
        Id = Guid.NewGuid(),
        CustomerId = command.CustomerId,
        Items = command.Items,
        Status = OrderStatus.Pending
    };
    
    await _orderRepository.AddAsync(order);
    
    // Публикация события для других сервисов
    await _eventBus.PublishAsync(new OrderCreatedEvent
    {
        OrderId = order.Id,
        CustomerId = order.CustomerId,
        Items = order.Items
    });
}

// Пример оркестратора для создания заказа
public class CreateOrderSaga : ISaga<CreateOrderSagaState>
{
    public Task<CreateOrderSagaState> InitiateAsync(CreateOrderCommand command)
    {
        return Task.FromResult(new CreateOrderSagaState
        {
            OrderId = Guid.NewGuid(),
            CustomerId = command.CustomerId,
            Items = command.Items,
            Step = CreateOrderSagaStep.Started
        });
    }
    
    public Task<CreateOrderSagaState> HandleAsync(CreateOrderSagaState state, object message)
    {
        switch (state.Step)
        {
            case CreateOrderSagaStep.Started:
                return HandleStarted(state, message as OrderCreatedEvent);
            case CreateOrderSagaStep.CustomerVerified:
                return HandleCustomerVerified(state, message as CustomerVerifiedEvent);
            // Другие шаги...
        }
        
        throw new InvalidOperationException($"Unknown step: {state.Step}");
    }
    
    // Методы обработки для каждого шага...
}

// Пример интеграции с Event Sourcing
public class OrderAggregate : EventSourcedAggregate
{
    private OrderState _state;
    
    public void Process(CreateOrderCommand command)
    {
        // Проверка возможности создания заказа
        if (_state.Status != OrderStatus.None)
            throw new InvalidOperationException("Order already exists");
            
        // Применение события, которое будет сохранено в event store
        ApplyEvent(new OrderCreatedEvent(command.OrderId, command.CustomerId));
    }
    
    // Обработчик события
    private void Apply(OrderCreatedEvent evt)
    {
        _state.Id = evt.OrderId;
        _state.CustomerId = evt.CustomerId;
        _state.Status = OrderStatus.Pending;
    }
}

// Пример команды, запускающей SAGA
public class CreateOrderCommandHandler : ICommandHandler<CreateOrderCommand>
{
    private readonly ISagaCoordinator _sagaCoordinator;
    
    public async Task HandleAsync(CreateOrderCommand command)
    {
        // Запуск SAGA через координатор
        await _sagaCoordinator.StartSagaAsync<CreateOrderSaga>(command);
    }
}
 
// Пример запроса, использующего денормализованное представление
public class GetOrderQueryHandler : IQueryHandler<GetOrderQuery, OrderDto>
{
    private readonly IReadDbContext _readDb;
    
    public async Task<OrderDto> HandleAsync(GetOrderQuery query)
    {
        // Чтение из оптимизированной для запросов базы
        return await _readDb.Orders
            .Include(o => o.Items)
            .Where(o => o.Id == query.OrderId)
            .ProjectTo<OrderDto>()
            .FirstOrDefaultAsync();
    }
}

// Двухфазный коммит (при условии поддержки XA)
public void ProcessOrder_2PC(Order order)
{
    using (var scope = new TransactionScope(
        TransactionScopeOption.Required,
        new TransactionOptions { IsolationLevel = IsolationLevel.Serializable }))
    {
        _orderService.CreateOrder(order);
        _inventoryService.ReserveInventory(order);
        _paymentService.ProcessPayment(order);
        
        scope.Complete();
    } // При ошибке автоматически выполняется откат
}
 
// SAGA (упрощенно)
public async Task ProcessOrder_Saga(Order order)
{
    var orderCreated = await _orderService.CreateOrderAsync(order);
    if (!orderCreated.Success)
        return; // Первый шаг не выполнен
        
    var inventoryReserved = await _inventoryService.ReserveInventoryAsync(order);
    if (!inventoryReserved.Success)
    {
        // Компенсирующая транзакция
        await _orderService.CancelOrderAsync(order.Id);
        return;
    }
    
    var paymentProcessed = await _paymentService.ProcessPaymentAsync(order);
    if (!paymentProcessed.Success)
    {
        // Компенсирующие транзакции
        await _inventoryService.ReleaseInventoryAsync(order);
        await _orderService.CancelOrderAsync(order.Id);
        return;
    }
    
    // Все шаги успешно выполнены
}

public class OrderProcessingSaga : Saga<OrderSagaData>,
    IAmStartedByMessages<StartOrderProcessing>
{
    private readonly IServiceBus _bus;
    
    public OrderProcessingSaga(IServiceBus bus)
    {
        _bus = bus;
    }
    
    public async Task Handle(StartOrderProcessing message)
    {
        Data.OrderId = message.OrderId;
        
        // Запуск дочерней SAGA для проверки клиента
        await _bus.SendAsync(new StartCustomerVerification { 
            OrderId = message.OrderId, 
            CustomerId = message.CustomerId 
        });
        
        // Основная SAGA ждет завершения дочерних процессов
    }
    
    // Обработчики завершения дочерних SAGA...
}

// Пример использования MassTransit для создания SAGA
public class OrderStateMachine : MassTransitStateMachine<OrderState>
{
    public OrderStateMachine()
    {
        InstanceState(x => x.CurrentState);
        
        Initially(
            When(OrderSubmitted)
                .Then(context => {
                    context.Instance.OrderId = context.Data.OrderId;
                    context.Instance.CustomerId = context.Data.CustomerId;
                })
                .TransitionTo(Submitted)
                .Send(context => new VerifyCustomer {
                    OrderId = context.Instance.OrderId,
                    CustomerId = context.Instance.CustomerId
                })
        );
        
        During(Submitted,
            When(CustomerVerified)
                .TransitionTo(Verified)
                .Send(context => new ReserveInventory {
                    OrderId = context.Instance.OrderId,
                    Items = context.Data.Items
                })
        );
        
        // Другие состояния и переходы...
    }
    
    public State Submitted { get; private set; }
    public State Verified { get; private set; }
    
    public Event<OrderSubmittedEvent> OrderSubmitted { get; private set; }
    public Event<CustomerVerifiedEvent> CustomerVerified { get; private set; }
}

public interface IEvent
{
    Guid CorrelationId { get; }
    DateTime Timestamp { get; }
}
 
public interface IEventHandler<in TEvent> where TEvent : IEvent
{
    Task HandleAsync(TEvent @event);
}
 
public interface IEventBus
{
    Task PublishAsync<TEvent>(TEvent @event) where TEvent : IEvent;
    void Subscribe<TEvent, THandler>() 
        where TEvent : IEvent 
        where THandler : IEventHandler<TEvent>;
}

public class OrderCreatedEvent : IEvent
{
    public Guid CorrelationId { get; set; } // Совпадает с OrderId
    public DateTime Timestamp { get; set; } = DateTime.UtcNow;
    public Guid CustomerId { get; set; }
    public List<OrderItem> Items { get; set; }
    public decimal TotalAmount { get; set; }
}
 
public class CustomerVerifiedEvent : IEvent
{
    public Guid CorrelationId { get; set; }
    public DateTime Timestamp { get; set; } = DateTime.UtcNow;
    public Guid CustomerId { get; set; }
    public bool IsVerified { get; set; }
    public string RejectionReason { get; set; }
}
 
// Аналогично для других событий процесса

// В сервисе клиентов
public class OrderCreatedEventHandler : IEventHandler<OrderCreatedEvent>
{
    private readonly ICustomerRepository _customerRepository;
    private readonly IEventBus _eventBus;
 
    public OrderCreatedEventHandler(
        ICustomerRepository customerRepository,
        IEventBus eventBus)
    {
        _customerRepository = customerRepository;
        _eventBus = eventBus;
    }
 
    public async Task HandleAsync(OrderCreatedEvent @event)
    {
        var customer = await _customerRepository.GetByIdAsync(@event.CustomerId);
        
        var isVerified = customer != null && customer.Status == CustomerStatus.Active;
        var rejectionReason = !isVerified ? "Customer not found or inactive" : null;
        
        await _eventBus.PublishAsync(new CustomerVerifiedEvent
        {
            CorrelationId = @event.CorrelationId,
            CustomerId = @event.CustomerId,
            IsVerified = isVerified,
            RejectionReason = rejectionReason
        });
    }
}

public class OutboxEventBus : IEventBus
{
    private readonly IOutboxRepository _outboxRepository;
    private readonly IServiceProvider _serviceProvider;
 
    public OutboxEventBus(
        IOutboxRepository outboxRepository,
        IServiceProvider serviceProvider)
    {
        _outboxRepository = outboxRepository;
        _serviceProvider = serviceProvider;
    }
 
    public async Task PublishAsync<TEvent>(TEvent @event) where TEvent : IEvent
    {
        // Сохраняем событие в таблицу Outbox в той же транзакции,
        // что и основные изменения в базе данных
        await _outboxRepository.AddAsync(new OutboxMessage
        {
            Id = Guid.NewGuid(),
            CorrelationId = @event.CorrelationId,
            Type = typeof(TEvent).FullName,
            Data = JsonSerializer.Serialize(@event),
            CreatedAt = DateTime.UtcNow
        });
        
        // Отправка выполняется асинхронно фоновым процессом
    }
 
    // Метод подписки...
}

public class CreateOrderSagaState
{
    public Guid Id { get; set; }
    public Guid OrderId { get; set; }
    public Guid CustomerId { get; set; }
    public List<OrderItem> Items { get; set; }
    public decimal TotalAmount { get; set; }
    public CreateOrderSagaStatus Status { get; set; }
    public string ErrorMessage { get; set; }
    
    // Дополнительные данные для каждого шага
    public bool IsCustomerVerified { get; set; }
    public bool IsInventoryReserved { get; set; }
    public bool IsPaymentProcessed { get; set; }
}
 
public enum CreateOrderSagaStatus
{
    NotStarted,
    OrderCreated,
    CustomerVerified,
    CustomerVerificationFailed,
    InventoryReserved,
    InventoryReservationFailed,
    PaymentProcessed,
    PaymentFailed,
    OrderCompleted,
    OrderFailed
}

public class CreateOrderSaga : 
    IRequestHandler<StartCreateOrderSagaCommand, Guid>,
    INotificationHandler<CustomerVerifiedEvent>,
    INotificationHandler<InventoryReservedEvent>,
    INotificationHandler<PaymentProcessedEvent>,
    INotificationHandler<SagaFailedEvent>
{
    private readonly ISagaRepository<CreateOrderSagaState> _sagaRepository;
    private readonly IMediator _mediator;
 
    public CreateOrderSaga(
        ISagaRepository<CreateOrderSagaState> sagaRepository,
        IMediator mediator)
    {
        _sagaRepository = sagaRepository;
        _mediator = mediator;
    }
 
    public async Task<Guid> Handle(StartCreateOrderSagaCommand request, CancellationToken cancellationToken)
    {
        // Создание состояния SAGA и заказа
        var state = new CreateOrderSagaState
        {
            Id = Guid.NewGuid(),
            OrderId = Guid.NewGuid(),
            CustomerId = request.CustomerId,
            Items = request.Items,
            TotalAmount = request.Items.Sum(i => i.Price * i.Quantity),
            Status = CreateOrderSagaStatus.NotStarted
        };
        
        await _sagaRepository.SaveAsync(state);
        
        // Создание заказа
        await _mediator.Send(new CreateOrderCommand
        {
            OrderId = state.OrderId,
            CustomerId = state.CustomerId,
            Items = state.Items,
            TotalAmount = state.TotalAmount,
            SagaId = state.Id
        });
        
        return state.Id;
    }
 
    public async Task Handle(CustomerVerifiedEvent notification, CancellationToken cancellationToken)
    {
        var state = await _sagaRepository.GetByIdAsync(notification.SagaId);
        
        if (notification.IsVerified)
        {
            state.Status = CreateOrderSagaStatus.CustomerVerified;
            state.IsCustomerVerified = true;
            
            // Следующий шаг - резервирование товаров
            await _mediator.Send(new ReserveInventoryCommand
            {
                OrderId = state.OrderId,
                Items = state.Items,
                SagaId = state.Id
            });
        }
        else
        {
            state.Status = CreateOrderSagaStatus.CustomerVerificationFailed;
            state.ErrorMessage = notification.RejectionReason;
            
            // Компенсация - отмена заказа
            await _mediator.Send(new CancelOrderCommand
            {
                OrderId = state.OrderId,
                Reason = notification.RejectionReason,
                SagaId = state.Id
            });
        }
        
        await _sagaRepository.SaveAsync(state);
    }
 
    // Другие обработчики событий...
}

public class SagaRepository<TSaga> : ISagaRepository<TSaga> where TSaga : class
{
    private readonly SagaDbContext _dbContext;
 
    public SagaRepository(SagaDbContext dbContext)
    {
        _dbContext = dbContext;
    }
 
    public async Task<TSaga> GetByIdAsync(Guid id)
    {
        return await _dbContext.Set<TSaga>().FindAsync(id);
    }
 
    public async Task SaveAsync(TSaga saga)
    {
        var entry = _dbContext.Entry(saga);
        
        if (entry.State == EntityState.Detached)
            await _dbContext.Set<TSaga>().AddAsync(saga);
            
        await _dbContext.SaveChangesAsync();
    }
}

public class SagaRetryPolicy<TCommand>
{
    private readonly IMediator _mediator;
    private readonly ISagaRepository<CreateOrderSagaState> _repository;
    
    public SagaRetryPolicy(
        IMediator mediator,
        ISagaRepository<CreateOrderSagaState> repository)
    {
        _mediator = mediator;
        _repository = repository;
    }
    
    public async Task ExecuteWithRetryAsync(TCommand command, Guid sagaId)
    {
        var policy = Policy
            .Handle<Exception>()
            .WaitAndRetryAsync(
                retryCount: 3, 
                sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
                onRetry: async (exception, timeSpan, retryCount, context) =>
                {
                    var state = await _repository.GetByIdAsync(sagaId);
                    state.ErrorMessage = $"Retry {retryCount}: {exception.Message}";
                    await _repository.SaveAsync(state);
                });
                
        await policy.ExecuteAsync(() => _mediator.Send(command));
    }
}

public class CreateOrderSagaRabbitMqSetup : IHostedService
{
    private readonly IBusControl _busControl;
    private readonly IServiceProvider _serviceProvider;
 
    public CreateOrderSagaRabbitMqSetup(
        IBusControl busControl,
        IServiceProvider serviceProvider)
    {
        _busControl = busControl;
        _serviceProvider = serviceProvider;
    }
 
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // Настройка маршрутизации сообщений
        _busControl.ConnectReceiveEndpoint("create-order-saga", endpoint =>
        {
            // Регистрация сообщений для оркестратора SAGA
            endpoint.Instance(_serviceProvider.GetRequiredService<CreateOrderSaga>());
            
            // Определение стратегии повторов
            endpoint.UseMessageRetry(r => r.Incremental(3, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)));
            
            // Автоматический перемещение ошибочных сообщений в очередь ошибок
            endpoint.UseDelayedRedelivery(r => r.Intervals(
                TimeSpan.FromMinutes(5),
                TimeSpan.FromMinutes(15),
                TimeSpan.FromMinutes(30)
            ));
        });
 
        await _busControl.StartAsync(cancellationToken);
    }
 
    public async Task StopAsync(CancellationToken cancellationToken)
    {
        await _busControl.StopAsync(cancellationToken);
    }
}

public class KafkaSagaEventConsumer : BackgroundService
{
    private readonly IConsumer<Ignore, string> _consumer;
    private readonly IMediator _mediator;
    private readonly ILogger<KafkaSagaEventConsumer> _logger;
 
    public KafkaSagaEventConsumer(
        IConsumer<Ignore, string> consumer,
        IMediator mediator,
        ILogger<KafkaSagaEventConsumer> logger)
    {
        _consumer = consumer;
        _mediator = mediator;
        _logger = logger;
    }
 
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _consumer.Subscribe("order-saga-events");
 
        try
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                var result = _consumer.Consume(stoppingToken);
                var eventJson = result.Message.Value;
                
                try
                {
                    // Десериализация события
                    var baseEvent = JsonSerializer.Deserialize<BaseEvent>(eventJson);
                    
                    // Динамическая маршрутизация события на основе его типа
                    Type eventType = Type.GetType(baseEvent.EventType);
                    var typedEvent = JsonSerializer.Deserialize(eventJson, eventType);
                    
                    // Отправка события через MediatR
                    await _mediator.Publish(typedEvent, stoppingToken);
                    
                    // Подтверждение обработки
                    _consumer.Commit(result);
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error processing saga event: {EventJson}", eventJson);
                }
            }
        }
        finally
        {
            _consumer.Close();
        }
    }
}

public class SagaMonitoringService
{
    private readonly IDatabase _redisDb;
    private readonly IServiceScopeFactory _scopeFactory;
 
    public SagaMonitoringService(
        IConnectionMultiplexer redis,
        IServiceScopeFactory scopeFactory)
    {
        _redisDb = redis.GetDatabase();
        _scopeFactory = scopeFactory;
    }
 
    public async Task TrackSagaProgressAsync<TState>(Guid sagaId, TState state, string currentStep)
    {
        var sagaInfo = new SagaProgressInfo
        {
            SagaId = sagaId,
            SagaType = typeof(TState).Name,
            CurrentStep = currentStep,
            Status = GetStatusFromState(state),
            LastUpdated = DateTime.UtcNow,
            StateSnapshot = JsonSerializer.Serialize(state)
        };
 
        // Сохранение в Redis для быстрого доступа
        await _redisDb.HashSetAsync(
            $"saga:{sagaId}", 
            new HashEntry[]
            {
                new HashEntry("status", sagaInfo.Status),
                new HashEntry("currentStep", sagaInfo.CurrentStep),
                new HashEntry("lastUpdated", sagaInfo.LastUpdated.ToString("o")),
                new HashEntry("stateSnapshot", sagaInfo.StateSnapshot)
            });
 
        // Публикация события для real-time обновлений через SignalR
        await _redisDb.PublishAsync("saga-progress-channel", JsonSerializer.Serialize(sagaInfo));
 
        // Сохранение в постоянное хранилище для истории
        using var scope = _scopeFactory.CreateScope();
        var repository = scope.ServiceProvider.GetRequiredService<ISagaMonitoringRepository>();
        await repository.SaveProgressAsync(sagaInfo);
    }
 
    private string GetStatusFromState<TState>(TState state)
    {
        // Извлечение статуса из свойств объекта состояния
        var statusProperty = typeof(TState).GetProperty("Status");
        return statusProperty?.GetValue(state)?.ToString() ?? "Unknown";
    }
}

public class SagaMonitoringHub : Hub
{
    private readonly IRedisSubscriber _redisSubscriber;
 
    public SagaMonitoringHub(IRedisSubscriber redisSubscriber)
    {
        _redisSubscriber = redisSubscriber;
    }
 
    public override async Task OnConnectedAsync()
    {
        // Подписка на канал обновлений SAGA
        _redisSubscriber.Subscribe("saga-progress-channel", async (message) =>
        {
            var progress = JsonSerializer.Deserialize<SagaProgressInfo>(message);
            await Clients.All.SendAsync("SagaProgressUpdated", progress);
        });
 
        await base.OnConnectedAsync();
    }
}

public class LongRunningSagaWithPolly<TState> where TState : class, ISagaState
{
    private readonly IServiceProvider _serviceProvider;
    private readonly ISagaRepository<TState> _repository;
    private readonly ILogger<LongRunningSagaWithPolly<TState>> _logger;
 
    public LongRunningSagaWithPolly(
        IServiceProvider serviceProvider,
        ISagaRepository<TState> repository,
        ILogger<LongRunningSagaWithPolly<TState>> logger)
    {
        _serviceProvider = serviceProvider;
        _repository = repository;
        _logger = logger;
    }
 
    public async Task ExecuteWithTimeoutAndRetryAsync(
        Guid sagaId, 
        Func<TState, Task<bool>> action,
        TimeSpan timeout,
        int maxRetries = 3)
    {
        // Политика таймаута
        var timeoutPolicy = Policy.TimeoutAsync(timeout);
 
        // Политика повторов с экспоненциальной задержкой
        var retryPolicy = Policy
            .Handle<Exception>()
            .WaitAndRetryAsync(
                maxRetries,
                attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
                async (ex, delay, attempt, ctx) =>
                {
                    _logger.LogWarning(ex, 
                        "Error executing saga step (Attempt {Attempt}/{MaxRetries}). Retrying in {Delay}s",
                        attempt, maxRetries, delay.TotalSeconds);
                    
                    // Обновление состояния SAGA с информацией о повторе
                    var state = await _repository.GetByIdAsync(sagaId);
                    state.LastError = ex.Message;
                    state.RetryCount = attempt;
                    state.NextRetryAt = DateTime.UtcNow.Add(delay);
                    await _repository.SaveAsync(state);
                });
 
        // Комбинирование политик
        var combinedPolicy = Policy.WrapAsync(retryPolicy, timeoutPolicy);
 
        try
        {
            await combinedPolicy.ExecuteAsync(async (ctx) =>
            {
                var state = await _repository.GetByIdAsync(sagaId);
                bool isCompleted = await action(state);
                
                // Если шаг не завершен, имитируем исключение для активации повтора
                if (!isCompleted)
                    throw new SagaStepIncompleteException("Step not completed, will retry later");
                
                return isCompleted;
            }, new Context($"Saga_{sagaId}"));
        }
        catch (TimeoutRejectedException)
        {
            // Обработка превышения общего таймаута
            var state = await _repository.GetByIdAsync(sagaId);
            state.Status = SagaStatus.TimedOut;
            state.LastError = "Saga execution timed out";
            await _repository.SaveAsync(state);
            
            // Запуск компенсационной логики
            await InitiateCompensationAsync(sagaId);
        }
        catch (Exception ex) when (ex is not SagaStepIncompleteException)
        {
            // Обработка других ошибок
            _logger.LogError(ex, "Unhandled error in saga execution");
            
            var state = await _repository.GetByIdAsync(sagaId);
            state.Status = SagaStatus.Failed;
            state.LastError = ex.Message;
            await _repository.SaveAsync(state);
            
            // Запуск компенсационной логики
            await InitiateCompensationAsync(sagaId);
        }
    }
 
    private async Task InitiateCompensationAsync(Guid sagaId)
    {
        // Логика запуска компенсационных действий
        // ...
    }
}

public async Task ResumeFromCheckpointAsync(Guid sagaId)
{
    var state = await _repository.GetByIdAsync(sagaId);
    
    // Определение следующего шага на основе текущего состояния
    switch (state.CurrentCheckpoint)
    {
        case "OrderCreated":
            await ExecuteWithTimeoutAndRetryAsync(
                sagaId,
                s => VerifyCustomerAsync(s),
                TimeSpan.FromMinutes(5));
            break;
            
        case "CustomerVerified":
            await ExecuteWithTimeoutAndRetryAsync(
                sagaId,
                s => ReserveInventoryAsync(s),
                TimeSpan.FromMinutes(10));
            break;
            
        // Другие шаги...
    }
}

public class AzureServiceBusSagaOrchestrator : ISagaOrchestrator
{
    private readonly ServiceBusClient _client;
    private readonly ServiceBusSender _commandSender;
    private readonly ISagaRepository<OrderSagaState> _repository;
 
    public AzureServiceBusSagaOrchestrator(
        ServiceBusClient client,
        ISagaRepository<OrderSagaState> repository)
    {
        _client = client;
        _commandSender = client.CreateSender("saga-commands");
        _repository = repository;
    }
 
    public async Task<Guid> StartSagaAsync(StartOrderSagaCommand command)
    {
        // Создание состояния SAGA
        var state = new OrderSagaState
        {
            Id = Guid.NewGuid(),
            OrderId = Guid.NewGuid(),
            CustomerId = command.CustomerId,
            Items = command.Items,
            Status = SagaStatus.Started,
            CreatedAt = DateTime.UtcNow
        };
        
        await _repository.SaveAsync(state);
        
        // Отправка команды создания заказа с указанием sessionId для корреляции
        var createOrderCommand = new ServiceBusMessage(JsonSerializer.SerializeToUtf8Bytes(
            new CreateOrderCommand
            {
                SagaId = state.Id,
                OrderId = state.OrderId,
                CustomerId = state.CustomerId,
                Items = state.Items
            }))
        {
            SessionId = state.Id.ToString(),  // Использование SagaId как идентификатора сессии
            MessageId = Guid.NewGuid().ToString(),
            Subject = "CreateOrder"
        };
        
        await _commandSender.SendMessageAsync(createOrderCommand);
        
        return state.Id;
    }
 
    public async Task HandleResponseAsync(ServiceBusReceivedMessage message)
    {
        var sagaId = Guid.Parse(message.SessionId);
        var state = await _repository.GetByIdAsync(sagaId);
        
        // Обработка ответа в зависимости от темы сообщения
        switch (message.Subject)
        {
            case "OrderCreated":
                await HandleOrderCreatedAsync(state, message);
                break;
                
            case "CustomerVerified":
                await HandleCustomerVerifiedAsync(state, message);
                break;
                
            // Другие обработчики...
        }
    }
 
    private async Task HandleOrderCreatedAsync(OrderSagaState state, ServiceBusReceivedMessage message)
    {
        // Обновление состояния
        state.Status = SagaStatus.OrderCreated;
        await _repository.SaveAsync(state);
        
        // Отправка следующей команды
        var verifyCustomerCommand = new ServiceBusMessage(JsonSerializer.SerializeToUtf8Bytes(
            new VerifyCustomerCommand
            {
                SagaId = state.Id,
                CustomerId = state.CustomerId
            }))
        {
            SessionId = state.Id.ToString(),
            MessageId = Guid.NewGuid().ToString(),
            Subject = "VerifyCustomer"
        };
        
        await _commandSender.SendMessageAsync(verifyCustomerCommand);
    }
}

public class AzureServiceBusSagaProcessor : BackgroundService
{
    private readonly ServiceBusClient _client;
    private readonly ISagaOrchestrator _orchestrator;
    private readonly ILogger<AzureServiceBusSagaProcessor> _logger;
    private ServiceBusSessionProcessor _processor;
 
    public AzureServiceBusSagaProcessor(
        ServiceBusClient client,
        ISagaOrchestrator orchestrator,
        ILogger<AzureServiceBusSagaProcessor> logger)
    {
        _client = client;
        _orchestrator = orchestrator;
        _logger = logger;
    }
 
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // Создание процессора сообщений с поддержкой сессий
        _processor = _client.CreateSessionProcessor(
            "saga-responses",
            new ServiceBusSessionProcessorOptions
            {
                MaxConcurrentSessions = 100,
                MaxConcurrentCallsPerSession = 1,
                AutoCompleteMessages = false
            });
 
        // Настройка обработчиков
        _processor.ProcessMessageAsync += ProcessMessageAsync;
        _processor.ProcessErrorAsync += ProcessErrorAsync;
 
        await _processor.StartProcessingAsync(stoppingToken);
 
        try
        {
            await Task.Delay(Timeout.Infinite, stoppingToken);
        }
        catch (OperationCanceledException)
        {
            // Ожидаемое исключение при остановке сервиса
        }
        finally
        {
            await _processor.StopProcessingAsync();
        }
    }
 
    private async Task ProcessMessageAsync(ProcessSessionMessageEventArgs args)
    {
        try
        {
            await _orchestrator.HandleResponseAsync(args.Message);
            await args.CompleteMessageAsync(args.Message);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing saga response");
            
            // В зависимости от типа ошибки решаем, откладывать сообщение или отправлять в dead-letter
            if (IsTransientError(ex))
                await args.AbandonMessageAsync(args.Message);
            else
                await args.DeadLetterMessageAsync(args.Message, ex.Message);
        }
    }
 
    private Task ProcessErrorAsync(ProcessErrorEventArgs args)
    {
        _logger.LogError(args.Exception, "Error in service bus processor");
        return Task.CompletedTask;
    }
 
    private bool IsTransientError(Exception ex)
    {
        // Определение, является ли ошибка временной
        return ex is TimeoutException || ex is ServiceBusException sbEx && sbEx.IsTransient;
    }
}

public async Task ScheduleTimeoutAsync(Guid sagaId, string timeoutName, TimeSpan delay)
{
    var timeoutMessage = new ServiceBusMessage(JsonSerializer.SerializeToUtf8Bytes(
        new SagaTimeoutMessage
        {
            SagaId = sagaId,
            TimeoutName = timeoutName
        }))
    {
        SessionId = sagaId.ToString(),
        Subject = "SagaTimeout",
        MessageId = Guid.NewGuid().ToString()
    };
    
    // Планирование сообщения на будущее время
    timeoutMessage.ScheduledEnqueueTime = DateTimeOffset.UtcNow.Add(delay);
    
    await _commandSender.SendMessageAsync(timeoutMessage);
}

public async Task Handle(PaymentFailedEvent notification, CancellationToken cancellationToken)
{
    var state = await _sagaRepository.GetByIdAsync(notification.SagaId);
    
    state.Status = CreateOrderSagaStatus.PaymentFailed;
    state.ErrorMessage = notification.FailureReason;
    
    // Компенсирующая транзакция для отмены резервирования товара
    if (state.IsInventoryReserved)
    {
        await _mediator.Send(new CancelInventoryReservationCommand
        {
            OrderId = state.OrderId,
            Reason = "Payment failed: " + notification.FailureReason,
            SagaId = state.Id
        });
    }
    
    // Компенсирующая транзакция для отмены заказа
    await _mediator.Send(new RejectOrderCommand
    {
        OrderId = state.OrderId,
        Reason = "Payment failed: " + notification.FailureReason,
        SagaId = state.Id
    });
    
    await _sagaRepository.SaveAsync(state);
}

// В сервисе инвентаризации
public class PaymentFailedEventHandler : IEventHandler<PaymentFailedEvent>
{
    private readonly IInventoryRepository _inventoryRepository;
    private readonly IEventBus _eventBus;
    
    public async Task HandleAsync(PaymentFailedEvent @event)
    {
        // Найти резервирование по идентификатору заказа
        var reservation = await _inventoryRepository.GetByOrderIdAsync(@event.OrderId);
        
        if (reservation != null)
        {
            // Отменить резервирование
            reservation.Status = ReservationStatus.Cancelled;
            reservation.CancellationReason = "Payment failed: " + @event.FailureReason;
            
            await _inventoryRepository.UpdateAsync(reservation);
            
            // Опубликовать событие об отмене резервирования
            await _eventBus.PublishAsync(new InventoryReservationCancelledEvent
            {
                CorrelationId = @event.CorrelationId,
                OrderId = @event.OrderId,
                Reason = reservation.CancellationReason
            });
        }
    }
}

public async Task<bool> ProcessPaymentIdempotent(ProcessPaymentCommand command)
{
    // Проверка, была ли эта операция уже выполнена
    var existingTransaction = await _transactionRepository
        .GetByIdempotencyKeyAsync(command.IdempotencyKey);
    
    if (existingTransaction != null)
    {
        // Операция уже была выполнена, возвращаем предыдущий результат
        return existingTransaction.IsSuccessful;
    }
    
    // Выполнение операции и сохранение результата
    bool isSuccessful;
    try
    {
        // Основная логика обработки платежа
        await _paymentGateway.ChargeAsync(command.PaymentInfo);
        isSuccessful = true;
    }
    catch (Exception)
    {
        isSuccessful = false;
    }
    
    // Сохранение результата операции с идентификатором идемпотентности
    await _transactionRepository.SaveAsync(new PaymentTransaction
    {
        IdempotencyKey = command.IdempotencyKey,
        OrderId = command.OrderId,
        Amount = command.Amount,
        IsSuccessful = isSuccessful,
        Timestamp = DateTime.UtcNow
    });
    
    return isSuccessful;
}

public async Task ReserveInventoryIdempotent(ReserveInventoryCommand command)
{
    // Проверка текущего состояния
    var existingReservation = await _inventoryRepository
        .GetByOrderIdAsync(command.OrderId);
    
    // Если резервирование уже существует, не создаем новое
    if (existingReservation != null)
        return;
    
    // Создание нового резервирования
    var reservation = new InventoryReservation
    {
        Id = Guid.NewGuid(),
        OrderId = command.OrderId,
        Items = command.Items,
        Status = ReservationStatus.Pending,
        CreatedAt = DateTime.UtcNow
    };
    
    await _inventoryRepository.AddAsync(reservation);
}

public async Task UpdateOrderStatusIdempotent(Guid orderId, OrderStatus newStatus, OrderStatus expectedCurrentStatus)
{
    // Выполнение условного обновления
    int updatedRows = await _dbContext.Orders
        .Where(o => o.Id == orderId && o.Status == expectedCurrentStatus)
        .ExecuteUpdateAsync(o => o.SetProperty(x => x.Status, newStatus));
    
    // Если обновлено 0 строк, значит условие не выполнилось
    if (updatedRows == 0)
    {
        // Проверяем, не было ли обновление уже выполнено
        var currentOrder = await _dbContext.Orders.FindAsync(orderId);
        if (currentOrder.Status != newStatus)
        {
            throw new ConcurrencyException($"Cannot update order status. Expected {expectedCurrentStatus}, but found {currentOrder.Status}");
        }
    }
}

public async Task ExecuteStepWithRetryAsync(
    Guid sagaId, 
    Func<Task<bool>> stepAction,
    Func<Task> compensationAction,
    int maxRetries = 3)
{
    var retryPolicy = Policy
        .Handle<Exception>()
        .WaitAndRetryAsync(
            maxRetries,
            attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
            async (ex, timeSpan, retryCount, context) =>
            {
                _logger.LogWarning(ex, 
                    "Step failed. Retry {RetryCount}/{MaxRetries} in {Delay}s",
                    retryCount, maxRetries, timeSpan.TotalSeconds);
                
                // Обновление метаданных SAGA
                await UpdateSagaMetadataAsync(sagaId, ex.Message, retryCount);
            });
            
    try
    {
        await retryPolicy.ExecuteAsync(stepAction);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Step failed after all retries. Executing compensation");
        
        // Если все попытки исчерпаны, выполняем компенсацию
        await compensationAction();
        
        // Обновление статуса SAGA
        await SetSagaStatusToFailedAsync(sagaId, ex.Message);
    }
}

public class SagaStateManager<TState> where TState : class, ISagaState
{
    private readonly ISagaRepository<TState> _repository;
    private readonly ILogger<SagaStateManager<TState>> _logger;
    
    public async Task<SagaRecoveryDecision> DetermineRecoveryActionAsync(Guid sagaId)
    {
        var state = await _repository.GetByIdAsync(sagaId);
        
        if (state == null)
            return SagaRecoveryDecision.Abort;
            
        // Анализ состояния для определения стратегии восстановления
        if (state.RetryCount >= state.MaxRetries)
            return SagaRecoveryDecision.Compensate;
            
        if (state.LastExecutedStepIndex < 0)
            return SagaRecoveryDecision.Restart;
            
        if (IsTimeoutExceeded(state.StartedAt))
            return SagaRecoveryDecision.Compensate;
            
        return SagaRecoveryDecision.RetryFromLastStep;
    }
    
    private bool IsTimeoutExceeded(DateTime startedAt)
    {
        var sagaDuration = DateTime.UtcNow - startedAt;
        return sagaDuration > TimeSpan.FromHours(1); // Настраиваемый максимальный срок
    }
}
 
public enum SagaRecoveryDecision
{
    Restart,
    RetryFromLastStep,
    Compensate,
    Abort
}

public class OrderService
{
    private readonly OrderDbContext _dbContext;
    private readonly IOutboxMessageRepository _outboxRepository;
    
    public async Task CreateOrderAsync(CreateOrderCommand command)
    {
        using var transaction = await _dbContext.Database.BeginTransactionAsync();
        
        try
        {
            // 1. Создание заказа
            var order = new Order
            {
                Id = command.OrderId,
                CustomerId = command.CustomerId,
                Status = OrderStatus.Pending,
                Items = command.Items.Select(i => new OrderItem { /* ... */ }).ToList()
            };
            
            _dbContext.Orders.Add(order);
            
            // 2. Сохранение события в таблицу Outbox (в той же транзакции)
            var outboxMessage = new OutboxMessage
            {
                Id = Guid.NewGuid(),
                Type = "OrderCreated",
                Content = JsonSerializer.Serialize(new OrderCreatedEvent
                {
                    OrderId = order.Id,
                    CustomerId = order.CustomerId,
                    Items = order.Items.Select(i => new OrderItemDto { /* ... */ }).ToList()
                }),
                CreatedAt = DateTime.UtcNow,
                ProcessedAt = null
            };
            
            _outboxRepository.Add(outboxMessage);
            
            // 3. Фиксация транзакции
            await _dbContext.SaveChangesAsync();
            await transaction.CommitAsync();
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
}

public class OutboxProcessor : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger<OutboxProcessor> _logger;
    private readonly TimeSpan _pollingInterval = TimeSpan.FromSeconds(5);
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                using var scope = _scopeFactory.CreateScope();
                var outboxService = scope.ServiceProvider.GetRequiredService<IOutboxService>();
                
                // Обработка сообщений из Outbox
                await outboxService.ProcessPendingMessagesAsync(stoppingToken);
                
                // Ожидание перед следующей итерацией
                await Task.Delay(_pollingInterval, stoppingToken);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                _logger.LogError(ex, "Error processing outbox messages");
                await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
            }
        }
    }
}

public class SagaLogger<TSaga> where TSaga : class
{
    private readonly ISagaRepository _repository;
    private readonly ILogger _logger;
    
    public async Task LogTransitionAsync(
        Guid sagaId, 
        string fromState, 
        string toState, 
        object context = null)
    {
        // Сохранение в журнал аудита
        var logEntry = new SagaLogEntry
        {
            SagaId = sagaId,
            SagaType = typeof(TSaga).Name,
            FromState = fromState,
            ToState = toState,
            Timestamp = DateTime.UtcNow,
            Context = context != null ? JsonSerializer.Serialize(context) : null
        };
        
        await _repository.SaveLogEntryAsync(logEntry);
        
        // Структурированное логирование
        using (_logger.BeginScope(new Dictionary<string, object>
        {
            ["SagaId"] = sagaId,
            ["SagaType"] = typeof(TSaga).Name
        }))
        {
            _logger.LogInformation(
                "Saga transition: {FromState} -> {ToState}",
                fromState, toState);
        }
    }
    
    public async Task LogErrorAsync(
        Guid sagaId,
        string state,
        Exception exception,
        object context = null)
    {
        // Запись ошибки в журнал аудита
        var errorEntry = new SagaErrorEntry
        {
            SagaId = sagaId,
            SagaType = typeof(TSaga).Name,
            State = state,
            ErrorType = exception.GetType().Name,
            ErrorMessage = exception.Message,
            StackTrace = exception.StackTrace,
            Timestamp = DateTime.UtcNow,
            Context = context != null ? JsonSerializer.Serialize(context) : null
        };
        
        await _repository.SaveErrorEntryAsync(errorEntry);
        
        // Структурированное логирование ошибки
        using (_logger.BeginScope(new Dictionary<string, object>
        {
            ["SagaId"] = sagaId,
            ["SagaType"] = typeof(TSaga).Name,
            ["State"] = state
        }))
        {
            _logger.LogError(exception, "Saga error occurred");
        }
    }
}

public class SagaVisualizerService
{
    private readonly ISagaLogRepository _logRepository;
    
    public async Task<SagaVisualizationDto> GenerateSagaFlowDiagramAsync(Guid sagaId)
    {
        // Получение всех записей лога для данной SAGA
        var logs = await _logRepository.GetBySagaIdAsync(sagaId);
        
        // Построение временной шкалы выполнения
        var timeline = logs
            .OrderBy(l => l.Timestamp)
            .Select(l => new SagaTimelineItemDto
            {
                Timestamp = l.Timestamp,
                State = l.ToState,
                Duration = l.DurationMs,
                IsError = l is SagaErrorEntry
            })
            .ToList();
        
        // Формирование графа состояний
        var stateGraph = BuildStateGraph(logs);
        
        return new SagaVisualizationDto
        {
            SagaId = sagaId,
            StartedAt = logs.Min(l => l.Timestamp),
            CompletedAt = logs.Max(l => l.Timestamp),
            CurrentState = logs.OrderByDescending(l => l.Timestamp).First().ToState,
            Timeline = timeline,
            StateGraph = stateGraph
        };
    }
    
    private List<StateTransitionDto> BuildStateGraph(IEnumerable<SagaLogEntry> logs)
    {
        // Логика построения графа состояний
        // ...
        
        return new List<StateTransitionDto>();
    }
}

public async Task<bool> TryAcquireOrderLockAsync(Guid orderId, Guid lockOwnerId)
{
    // Попытка установить блокировку атомарной операцией
    int updatedRows = await _dbContext.Orders
        .Where(o => o.Id == orderId && (o.LockOwnerId == null || o.LockExpiresAt < DateTime.UtcNow))
        .ExecuteUpdateAsync(o => o
            .SetProperty(x => x.LockOwnerId, lockOwnerId)
            .SetProperty(x => x.LockExpiresAt, DateTime.UtcNow.AddMinutes(5)));
            
    return updatedRows > 0;
}

public async Task UpdateInventoryWithOptimisticLockAsync(
    UpdateInventoryCommand command)
{
    var inventory = await _dbContext.InventoryItems
        .FindAsync(command.ProductId);
        
    if (inventory == null)
        throw new NotFoundException($"Product {command.ProductId} not found");
        
    if (inventory.Version != command.ExpectedVersion)
        throw new ConcurrencyException("Inventory has been modified by another transaction");
        
    inventory.Quantity -= command.QuantityToReserve;
    inventory.Version++; // Увеличение версии
    
    await _dbContext.SaveChangesAsync();
}

public async Task<bool> ApproveOrderWithRereadAsync(Guid orderId)
{
    // Чтение заказа
    var order = await _dbContext.Orders.FindAsync(orderId);
    
    if (order == null)
        return false;
        
    // Проверка, что заказ всё ещё в ожидании и не был отменен другой транзакцией
    if (order.Status != OrderStatus.Pending)
        return false;
        
    // Обновление статуса
    order.Status = OrderStatus.Approved;
    await _dbContext.SaveChangesAsync();
    
    return true;
}

public async Task RecordPaymentOperationAsync(PaymentOperation operation)
{
    // Добавление операции в историю
    await _dbContext.PaymentOperations.AddAsync(new PaymentOperationEntity
    {
        Id = Guid.NewGuid(),
        AccountId = operation.AccountId,
        OperationType = operation.Type,
        Amount = operation.Amount,
        Timestamp = DateTime.UtcNow,
        ReferenceId = operation.ReferenceId,
        ProcessedOrder = await GetNextOperationOrderAsync(operation.AccountId)
    });
    
    await _dbContext.SaveChangesAsync();
    
    // Асинхронная обработка операций в правильном порядке
    _ = Task.Run(() => ReprocessOperationsAsync(operation.AccountId));
}

public async Task ExecuteSagaStepAsync(Guid sagaId, string stepName, Func<Task> action)
{
    using var activity = _activitySource.StartActivity($"SagaStep:{stepName}");
    activity?.SetTag("saga.id", sagaId);
    
    try
    {
        await action();
        activity?.SetStatus(ActivityStatusCode.Ok);
    }
    catch (Exception ex)
    {
        activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
        throw;
    }
}

public class OrderSagaIntegrationTests : IClassFixture<TestContainersFixture>
{
    private readonly TestContainersFixture _fixture;
    
    public OrderSagaIntegrationTests(TestContainersFixture fixture)
    {
        _fixture = fixture;
    }
    
    [Fact]
    public async Task CompleteOrderSaga_WhenAllStepsSucceed_OrderApproved()
    {
        // Arrange
        var sagaId = await _fixture.OrderApi.StartCreateOrderSagaAsync(
            new CreateOrderRequest { /* ... */ });
        
        // Act
        await _fixture.WaitForSagaCompletionAsync(sagaId, TimeSpan.FromSeconds(30));
        
        // Assert
        var sagaState = await _fixture.SagaRepository.GetByIdAsync(sagaId);
        Assert.Equal(SagaStatus.Completed, sagaState.Status);
        
        var order = await _fixture.OrderRepository.GetByIdAsync(sagaState.OrderId);
        Assert.Equal(OrderStatus.Approved, order.Status);
    }
}

[Fact]
public async Task OrderSaga_WhenPaymentServiceUnavailable_RetryAndEventuallySucceed()
{
    // Arrange
    await _fixture.ChaosProxy.ConfigureAsync(new ChaosConfiguration
    {
        TargetService = "payment-service",
        FailureMode = FailureMode.TemporaryUnavailable,
        Duration = TimeSpan.FromSeconds(10)
    });
    
    var sagaId = await _fixture.OrderApi.StartCreateOrderSagaAsync(
        new CreateOrderRequest { /* ... */ });
    
    // Act
    await _fixture.WaitForSagaCompletionAsync(sagaId, TimeSpan.FromMinutes(2));
    
    // Assert
    var sagaState = await _fixture.SagaRepository.GetByIdAsync(sagaId);
    Assert.Equal(SagaStatus.Completed, sagaState.Status);
}

public async Task ExecuteSagaStepWithCircuitBreakerAsync(string serviceName, Func<Task> action)
{
    var circuitBreaker = _registry.GetCircuitBreaker(serviceName);
    
    await circuitBreaker.ExecuteAsync(async () =>
    {
        try
        {
            await action();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Service {ServiceName} failed", serviceName);
            throw;
        }
    });
}

// Шлюз, перенаправляющий запросы между монолитом и микросервисами
public class StranglerFacade : IOrderProcessor
{
    private readonly ILegacyOrderSystem _monolith;
    private readonly IOrderService _microservice;
    private readonly IFeatureToggleManager _featureToggles;
 
    public async Task<OrderResult> ProcessOrderAsync(CreateOrderCommand command)
    {
        // Проверка флага переключения
        if (_featureToggles.IsEnabled("UseNewOrderService"))
        {
            // Запуск SAGA в новом микросервисе
            return await _microservice.StartOrderSagaAsync(command);
        }
        
        // Использование старой логики монолита
        return await _monolith.CreateOrderAsync(command);
    }
}

public class AntiCorruptionLayer : IOrderRepository
{
    private readonly LegacyOrderDatabase _legacyDb;
    private readonly IEventBus _eventBus;
    
    public async Task<Order> GetOrderAsync(Guid orderId)
    {
        // Получение данных из монолита
        var legacyOrder = await _legacyDb.GetOrderAsync(orderId);
        
        // Преобразование в новую модель
        return MapToNewModel(legacyOrder);
    }
    
    public async Task UpdateOrderAsync(Order order)
    {
        // Обновление в монолите
        await _legacyDb.UpdateOrderAsync(MapToLegacyModel(order));
        
        // Публикация события для микросервисов
        await _eventBus.PublishAsync(new OrderUpdatedEvent
        {
            OrderId = order.Id,
            NewStatus = order.Status,
            UpdatedBy = "AntiCorruptionLayer"
        });
    }
}

// В монолите добавляем публикацию событий
public class LegacyOrderService
{
    private readonly IEventBus _eventBus;
    
    public void ProcessOrder(OrderData data)
    {
        // Существующая логика
        var orderResult = _legacyProcessingLogic.Process(data);
        
        // Дополнительно публикуем события для микросервисов
        _eventBus.Publish(new LegacyOrderProcessedEvent
        {
            OrderId = orderResult.Id,
            Status = orderResult.Status,
            // Другие данные...
        });
    }
}

public class HybridOrderSaga : ISagaOrchestrator
{
    private readonly MonolithTransactionProxy _monolithProxy;
    private readonly ICustomerService _customerService;
    private readonly IPaymentService _paymentService;
    
    public async Task<Guid> StartOrderProcessingAsync(CreateOrderCommand command)
    {
        // Создание заказа и проверка запасов в монолите через транзакцию
        var monolithResult = await _monolithProxy.ExecuteInTransactionAsync(async () => {
            var orderResult = await _monolithProxy.CreateOrderAsync(command);
            var inventoryResult = await _monolithProxy.CheckInventoryAsync(command.Items);
            return new { OrderId = orderResult.OrderId, IsInventoryAvailable = inventoryResult.IsAvailable };
        });
        
        if (!monolithResult.IsInventoryAvailable)
            throw new InsufficientInventoryException();
            
        // Создание состояния SAGA
        var sagaState = new OrderSagaState
        {
            Id = Guid.NewGuid(),
            OrderId = monolithResult.OrderId,
            CustomerId = command.CustomerId,
            Status = SagaStatus.Started
        };
        
        await _repository.SaveAsync(sagaState);
        
        // Запуск SAGA для обработки оставшихся шагов в микросервисах
        await _customerService.VerifyCustomerAsync(new VerifyCustomerCommand { 
            SagaId = sagaState.Id,
            CustomerId = command.CustomerId 
        });
        
        return sagaState.Id;
    }
    
    // Остальные обработчики SAGA...
}

public class MigrationMetricsCollector
{
    private readonly IMetricsRegistry _registry;
    
    public void TrackTransactionExecution(string transactionType, bool isMonolith, TimeSpan duration, bool isSuccessful)
    {
        // Запись метрик выполнения транзакции
        _registry.RecordTimer($"transaction.{transactionType}.duration", duration);
        _registry.RecordCounter($"transaction.{transactionType}.count", 1);
        _registry.RecordCounter($"transaction.{transactionType}.{(isSuccessful ? "success" : "failure")}", 1);
        
        // Метрики для сравнения монолита и микросервисов
        var systemType = isMonolith ? "monolith" : "microservice";
        _registry.RecordTimer($"system.{systemType}.{transactionType}.duration", duration);
        _registry.RecordCounter($"system.{systemType}.{transactionType}.count", 1);
    }
}