Циклические зависимости в C#: методы управления и устранения

public class CustomerService 
{
    private OrderService _orderService;
    
    public CustomerService(OrderService orderService) 
    {
        _orderService = orderService;
    }
    
    public void ProcessCustomer() 
    {
        // Использование _orderService
    }
}
 
public class OrderService 
{
    private CustomerService _customerService;
    
    public OrderService(CustomerService customerService) 
    {
        _customerService = customerService;
    }
    
    public void ProcessOrder() 
    {
        // Использование _customerService
    }
}

InvalidOperationException: A circular dependency was detected for the service of type 'YourApp.Services.CustomerService'.

// NDepend CQLinq запрос для обнаружения циклических зависимостей
from n in Application.Namespaces
let nsDependent = n.NamespacesUsed
where nsDependent.Contains(n)
select new { n, Problem = "Self dependency" }

System.AggregateException: Some services are not able to be constructed (Error while validating the service descriptor...)

public class CustomerService
{
    public void ProcessCustomer()
    {
        // Запах циклических зависимостей
        var orderService = ServiceLocator.Current.GetInstance<IOrderService>();
        orderService.DoSomething();
    }
}

public class Transaction 
{
    public Account FromAccount { get; set; }
    public Account ToAccount { get; set; }
    // ...
}
 
public class Account
{
    public List<Transaction> IncomingTransactions { get; set; }
    public List<Transaction> OutgoingTransactions { get; set; }
    // ...
}

public interface IOrderService 
{
    void ProcessOrder();
    // Методы, которые действительно нужны CustomerService
}
 
public interface ICustomerService 
{
    void ProcessCustomer();
    // Методы, которые действительно нужны OrderService
}
 
public class CustomerService : ICustomerService 
{
    private readonly IOrderService _orderService;
    
    public CustomerService(IOrderService orderService) 
    {
        _orderService = orderService;
    }
    
    public void ProcessCustomer() 
    {
        // Использование _orderService
    }
}
 
public class OrderService : IOrderService 
{
    private readonly ICustomerService _customerService;
    
    public OrderService(ICustomerService customerService) 
    {
        _customerService = customerService;
    }
    
    public void ProcessOrder() 
    {
        // Использование _customerService
    }
}

public class CustomerService : ICustomerService 
{
    private readonly Func<IOrderService> _orderServiceFactory;
    
    public CustomerService(Func<IOrderService> orderServiceFactory) 
    {
        _orderServiceFactory = orderServiceFactory;
    }
    
    public void ProcessCustomer() 
    {
        var orderService = _orderServiceFactory();
        // Теперь можно использовать orderService
    }
}

public class CustomerService : ICustomerService 
{
    public IOrderService OrderService { get; set; }
    
    public void ProcessCustomer() 
    {
        if (OrderService == null)
            throw new InvalidOperationException("OrderService не установлен");
        
        // Использование OrderService
    }
}

// Определяем интерфейс посредника
public interface IMediator 
{
    void NotifyOrderProcessed(Order order);
    void NotifyCustomerProcessed(Customer customer);
}
 
// Реализуем посредника
public class ApplicationMediator : IMediator 
{
    private readonly IOrderServiceImpl _orderService;
    private readonly ICustomerServiceImpl _customerService;
    
    public ApplicationMediator(
        IOrderServiceImpl orderService, 
        ICustomerServiceImpl customerService) 
    {
        _orderService = orderService;
        _customerService = customerService;
    }
    
    public void NotifyOrderProcessed(Order order) 
    {
        _customerService.OnOrderProcessed(order);
    }
    
    public void NotifyCustomerProcessed(Customer customer) 
    {
        _orderService.OnCustomerProcessed(customer);
    }
}
 
// Сервисы теперь используют посредника
public class CustomerService : ICustomerServiceImpl 
{
    private readonly IMediator _mediator;
    
    public CustomerService(IMediator mediator) 
    {
        _mediator = mediator;
    }
    
    public void ProcessCustomer(Customer customer) 
    {
        // Обработка клиента
        _mediator.NotifyCustomerProcessed(customer);
    }
    
    public void OnOrderProcessed(Order order) 
    {
        // Реакция на обработку заказа
    }
}

// Определяем события
public class OrderProcessedEventArgs : EventArgs 
{
    public Order Order { get; }
    
    public OrderProcessedEventArgs(Order order) 
    {
        Order = order;
    }
}
 
// В сервисе заказов
public class OrderService : IOrderService 
{
    // Определяем событие
    public event EventHandler<OrderProcessedEventArgs> OrderProcessed;
    
    public void ProcessOrder(Order order) 
    {
        // Обработка заказа
        
        // Вызываем событие
        OnOrderProcessed(new OrderProcessedEventArgs(order));
    }
    
    protected virtual void OnOrderProcessed(OrderProcessedEventArgs e) 
    {
        OrderProcessed?.Invoke(this, e);
    }
}
 
// В сервисе клиентов
public class CustomerService : ICustomerService 
{
    public CustomerService(IOrderService orderService) 
    {
        // Подписываемся на события
        orderService.OrderProcessed += OnOrderProcessed;
    }
    
    private void OnOrderProcessed(object sender, OrderProcessedEventArgs e) 
    {
        // Реакция на событие
    }
}

ProjectRoot/
  ├── Common/
  │   └── Interfaces/
  │       ├── IOrderService.cs
  │       └── ICustomerService.cs
  ├── Services/
  │   ├── OrderService/
  │   │   └── OrderService.cs
  │   └── CustomerService/
  │       └── CustomerService.cs

// Определяем интерфейс наблюдателя
public interface IOrderObserver 
{
    void OnOrderStatusChanged(Order order);
}
 
// Определяем наблюдаемый объект
public class OrderSubject 
{
    private readonly List<IOrderObserver> _observers = new List<IOrderObserver>();
    
    public void Attach(IOrderObserver observer) 
    {
        if (!_observers.Contains(observer))
            _observers.Add(observer);
    }
    
    public void Detach(IOrderObserver observer) 
    {
        _observers.Remove(observer);
    }
    
    protected void NotifyObservers(Order order) 
    {
        foreach (var observer in _observers)
            observer.OnOrderStatusChanged(order);
    }
}
 
// OrderService наследует функциональность наблюдаемого объекта
public class OrderService : OrderSubject, IOrderService 
{
    public void ProcessOrder(Order order) 
    {
        // Обработка заказа
        
        // Уведомляем наблюдателей
        NotifyObservers(order);
    }
}
 
// CustomerService реализует интерфейс наблюдателя
public class CustomerService : ICustomerService, IOrderObserver 
{
    public void ProcessCustomer(Customer customer) 
    {
        // Обработка клиента
    }
    
    public void OnOrderStatusChanged(Order order) 
    {
        // Реакция на изменение заказа
    }
}

// Регистрация в ASP.NET Core
services.AddSingleton<IOrderService, OrderService>();
services.AddSingleton<ICustomerService, CustomerService>();
 
// Настройка наблюдателей после создания сервисов
var orderService = serviceProvider.GetService<IOrderService>();
var customerService = serviceProvider.GetService<ICustomerService>();
 
if (orderService is OrderService concreteOrderService && 
    customerService is CustomerService concreteCustomerService)
{
    concreteOrderService.Attach(concreteCustomerService);
}

public class CustomerService : ICustomerService 
{
  // Обратите внимание: не OrderService, а Lazy<IOrderService>
  private readonly Lazy<IOrderService> _lazyOrderService;
  
  public CustomerService(Lazy<IOrderService> lazyOrderService) 
  {
      _lazyOrderService = lazyOrderService;
  }
  
  public void ProcessCustomer(Customer customer) 
  {
      // Доступ к сервису только когда он действительно нужен
      var orderService = _lazyOrderService.Value;
      // Теперь можно использовать orderService
  }
}

// Регистрация сервисов
services.AddSingleton<IOrderService, OrderService>();
services.AddSingleton<ICustomerService, CustomerService>();
 
// Регистрация ленивых оберток
services.AddTransient(provider => 
    new Lazy<IOrderService>(() => provider.GetRequiredService<IOrderService>()));
services.AddTransient(provider => 
    new Lazy<ICustomerService>(() => provider.GetRequiredService<ICustomerService>()));

public class CustomerService : ICustomerService 
{
  public void ProcessCustomer(Customer customer) 
  {
      // Получаем сервис только когда он нужен
      var orderService = ServiceLocator.Current.GetService<IOrderService>();
      orderService.ProcessOrder(customer.PendingOrder);
  }
}

// Вместо одного крупного интерфейса
public interface ICustomerService 
{
  Customer GetCustomer(int id);
  void UpdateCustomer(Customer customer);
  void ProcessCustomerOrders(int customerId);  // Зависимость от заказов
}
 
// Лучше разделить на два
public interface ICustomerDataService 
{
  Customer GetCustomer(int id);
  void UpdateCustomer(Customer customer);
}
 
public interface ICustomerOrderProcessor 
{
  void ProcessCustomerOrders(int customerId);
}

public class InventoryService 
{
    private OrderProcessingService _orderProcessor;
    
    public InventoryService(OrderProcessingService orderProcessor)
    {
        _orderProcessor = orderProcessor;
    }
    
    public bool CheckAvailability(int productId, int quantity)
    {
        // Проверка наличия
        return true;
    }
    
    public void ReserveItems(Order order)
    {
        // Резервирование товаров
    }
}
 
public class OrderProcessingService
{
    private InventoryService _inventory;
    
    public OrderProcessingService(InventoryService inventory)
    {
        _inventory = inventory;
    }
    
    public bool ProcessOrder(Order order)
    {
        if (_inventory.CheckAvailability(order.ProductId, order.Quantity))
        {
            _inventory.ReserveItems(order);
            return true;
        }
        return false;
    }
}

public interface IInventoryService
{
    bool CheckAvailability(int productId, int quantity);
    void ReserveItems(Order order);
}
 
public interface IOrderProcessor
{
    bool ProcessOrder(Order order);
}
 
public class InventoryService : IInventoryService
{
    private readonly IOrderProcessor _orderProcessor;
    
    public InventoryService(IOrderProcessor orderProcessor)
    {
        _orderProcessor = orderProcessor;
    }
    
    public bool CheckAvailability(int productId, int quantity)
    {
        // Проверка наличия
        return true;
    }
    
    public void ReserveItems(Order order)
    {
        // Резервирование товаров
    }
}
 
public class OrderProcessingService : IOrderProcessor
{
    private readonly IInventoryService _inventory;
    
    public OrderProcessingService(IInventoryService inventory)
    {
        _inventory = inventory;
    }
    
    public bool ProcessOrder(Order order)
    {
        if (_inventory.CheckAvailability(order.ProductId, order.Quantity))
        {
            _inventory.ReserveItems(order);
            return true;
        }
        return false;
    }
}

// Проблема: обнаружится циклическая зависимость
services.AddScoped<InventoryService>();
services.AddScoped<OrderProcessingService>();
 
// Решение: используем фабричный метод
services.AddScoped<IInventoryService>(provider => {
    var orderProcessor = provider.GetRequiredService<IOrderProcessor>();
    return new InventoryService(orderProcessor);
});
 
services.AddScoped<IOrderProcessor>(provider => {
    var inventory = provider.GetRequiredService<IInventoryService>();
    return new OrderProcessingService(inventory);
});

public interface IMediator
{
    bool CheckInventory(int productId, int quantity);
    void ReserveInventory(Order order);
    bool ProcessOrder(Order order);
}
 
public class ApplicationMediator : IMediator
{
    private readonly InventoryService _inventory;
    private readonly OrderProcessingService _orderProcessor;
    
    public ApplicationMediator(InventoryService inventory, OrderProcessingService orderProcessor)
    {
        _inventory = inventory;
        _orderProcessor = orderProcessor;
    }
    
    public bool CheckInventory(int productId, int quantity)
    {
        return _inventory.CheckAvailabilityInternal(productId, quantity);
    }
    
    public void ReserveInventory(Order order)
    {
        _inventory.ReserveItemsInternal(order);
    }
    
    public bool ProcessOrder(Order order)
    {
        return _orderProcessor.ProcessOrderInternal(order);
    }
}
 
public class InventoryService
{
    private readonly IMediator _mediator;
    
    public InventoryService(IMediator mediator)
    {
        _mediator = mediator;
    }
    
    // Эти методы вызываются только медиатором
    internal bool CheckAvailabilityInternal(int productId, int quantity)
    {
        return true; // Реализация проверки
    }
    
    internal void ReserveItemsInternal(Order order)
    {
        // Реализация резервирования
    }
}
 
public class OrderProcessingService
{
    private readonly IMediator _mediator;
    
    public OrderProcessingService(IMediator mediator)
    {
        _mediator = mediator;
    }
    
    public bool SubmitOrder(Order order)
    {
        // Публичный метод для клиентов сервиса
        return _mediator.ProcessOrder(order);
    }
    
    // Этот метод вызывается только медиатором
    internal bool ProcessOrderInternal(Order order)
    {
        if (_mediator.CheckInventory(order.ProductId, order.Quantity))
        {
            _mediator.ReserveInventory(order);
            return true;
        }
        return false;
    }
}

// Небольшой трюк: первым регистрируем медиатор как Func для отложенной инициализации
services.AddScoped<Func<IMediator>>(provider => () => 
    provider.GetRequiredService<IMediator>());
 
// Регистрируем сервисы, внедряя фабрику медиатора
services.AddScoped<InventoryService>(provider => {
    var mediatorFactory = provider.GetRequiredService<Func<IMediator>>();
    return new InventoryService(mediatorFactory());
});
 
services.AddScoped<OrderProcessingService>(provider => {
    var mediatorFactory = provider.GetRequiredService<Func<IMediator>>();
    return new OrderProcessingService(mediatorFactory());
});
 
// Теперь можно зарегистрировать сам медиатор
services.AddScoped<IMediator, ApplicationMediator>();

// Фасад, который скрывает сложную систему платежей
public class PaymentProcessingFacade
{
    private readonly CardValidationService _cardValidator;
    private readonly FraudDetectionService _fraudDetector;
    private readonly PaymentGatewayService _paymentGateway;
    private readonly CustomerNotificationService _notifier;
    
    public PaymentProcessingFacade(
        CardValidationService cardValidator,
        FraudDetectionService fraudDetector,
        PaymentGatewayService paymentGateway,
        CustomerNotificationService notifier)
    {
        _cardValidator = cardValidator;
        _fraudDetector = fraudDetector;
        _paymentGateway = paymentGateway;
        _notifier = notifier;
    }
    
    public PaymentResult ProcessPayment(PaymentRequest request)
    {
        // 1. Валидация карты
        if (!_cardValidator.Validate(request.CardInfo))
            return PaymentResult.Failed("Invalid card details");
            
        // 2. Проверка на мошенничество
        var fraudCheck = _fraudDetector.Check(request);
        if (fraudCheck.IsSuspicious)
            return PaymentResult.Failed("Payment flagged as suspicious");
            
        // 3. Обработка платежа
        var gatewayResult = _paymentGateway.ProcessPayment(request);
        
        // 4. Уведомление клиента
        if (gatewayResult.IsSuccessful)
            _notifier.NotifyPaymentSuccess(request.CustomerId, gatewayResult.TransactionId);
        else
            _notifier.NotifyPaymentFailure(request.CustomerId, gatewayResult.ErrorMessage);
            
        return gatewayResult;
    }
}

// Типичная структура Clean Architecture проекта
namespace MyApp.Domain
{
  // Здесь только бизнес-сущности и бизнес-правила
  // Не зависит ни от чего внешнего
}
 
namespace MyApp.Application
{
  // Здесь бизнес-логика и сценарии использования
  // Зависит только от Domain
}
 
namespace MyApp.Infrastructure
{
  // Зависит от Domain и Application, но не наоборот
}
 
namespace MyApp.Presentation
{
  // Внешний слой, зависит от всех остальных
}

[Fact]
public void Domain_ShouldNotDependOn_OtherLayers()
{
    // Код, который проверяет, что сборка Domain не имеет ссылок
    // на другие слои приложения
    var domainAssembly = typeof(DomainEntity).Assembly;
    var references = domainAssembly.GetReferencedAssemblies();
    
    Assert.DoesNotContain(references, 
        r => r.Name.Contains("Application") || 
             r.Name.Contains("Infrastructure") || 
             r.Name.Contains("Presentation"));
}