Архитектура ПО для разработчиков или Зачем нам системное мышление

public class SendNotificationCommand : IRequest<bool>
{
    public int UserId { get; set; }
    public string Message { get; set; }
}
 
public class SendNotificationHandler : IRequestHandler<SendNotificationCommand, bool>
{
    private readonly IUserRepository _userRepository;
    private readonly INotificationService _notificationService;
    
    // Явная зависимость от репозитория пользователей
    public SendNotificationHandler(IUserRepository userRepository, 
                                   INotificationService notificationService)
    {
        _userRepository = userRepository;
        _notificationService = notificationService;
    }
    
    public async Task<bool> Handle(SendNotificationCommand request, CancellationToken cancellationToken)
    {
        var user = await _userRepository.GetByIdAsync(request.UserId);
        if (user == null) return false;
        
        return await _notificationService.SendAsync(user.Email, request.Message);
    }
}

public interface IDocument
{
    Guid Id { get; }
    DocumentStatus Status { get; }
    DateTime CreatedAt { get; }
    DateTime? ModifiedAt { get; }
    
    bool CanBeApproved();
    void Approve(User approver);
}
 
public class Invoice : IDocument
{
    // Реализация интерфейса
    
    // Специфичные для инвойса свойства и методы
    public decimal Amount { get; private set; }
    public List<InvoiceItem> Items { get; private set; }
    
    public void AddItem(InvoiceItem item)
    {
        if (Status != DocumentStatus.Draft)
            throw new InvalidOperationException("Cannot modify approved invoice");
            
        Items.Add(item);
        Amount += item.Price * item.Quantity;
        ModifiedAt = DateTime.UtcNow;
    }
}

public class OrderService
{
    private readonly CustomerRepository _customerRepo;
    private readonly ProductRepository _productRepo;
    private readonly PaymentService _paymentService;
    private readonly EmailService _emailService;
    private readonly InventoryService _inventoryService;
    
    public OrderService()
    {
        _customerRepo = new CustomerRepository();
        _productRepo = new ProductRepository();
        _paymentService = new PaymentService();
        _emailService = new EmailService();
        _inventoryService = new InventoryService();
    }
    
    // Методы класса...
}

public class OrderService
{
    private readonly ICustomerRepository _customerRepo;
    private readonly IProductRepository _productRepo;
    private readonly IPaymentProcessor _paymentProcessor;
    private readonly INotificationService _notificationService;
    private readonly IInventoryManager _inventoryManager;
    
    public OrderService(
        ICustomerRepository customerRepo,
        IProductRepository productRepo,
        IPaymentProcessor paymentProcessor,
        INotificationService notificationService,
        IInventoryManager inventoryManager)
    {
        _customerRepo = customerRepo;
        _productRepo = productRepo;
        _paymentProcessor = paymentProcessor;
        _notificationService = notificationService;
        _inventoryManager = inventoryManager;
    }
    
    // Методы класса...
}

// Публичный API модуля Order
public interface IOrderModule
{
    Task<Order> CreateOrderAsync(OrderRequest request);
    Task<Order> GetOrderByIdAsync(Guid orderId);
    Task<OrderStatus> GetOrderStatusAsync(Guid orderId);
    // Другие публичные методы...
}
 
// Реализация модуля - скрыта от внешнего мира
internal class OrderModule : IOrderModule
{
    // Внутренние компоненты модуля
    private readonly OrderService _orderService;
    private readonly OrderValidator _orderValidator;
    
    // Конструктор с DI
    public OrderModule(OrderService orderService, OrderValidator orderValidator)
    {
        _orderService = orderService;
        _orderValidator = orderValidator;
    }
    
    // Реализация интерфейса
    public async Task<Order> CreateOrderAsync(OrderRequest request)
    {
        var validationResult = _orderValidator.Validate(request);
        if (!validationResult.IsValid)
            throw new ValidationException(validationResult.Errors);
            
        return await _orderService.CreateAsync(request);
    }
    
    // Другие методы...
}

public async Task<OrderResult> ProcessOrderAsync(OrderRequest request)
{
    // Валидация - должна быть синхронной, чтобы быстро отсечь невалидные запросы
    var validationResult = _validator.Validate(request);
    if (!validationResult.IsValid)
        return OrderResult.Failed(validationResult.Errors);
        
    // Начинаем параллельные операции, которые не зависят друг от друга
    var customerTask = _customerRepository.GetByIdAsync(request.CustomerId);
    var productsTasks = request.Items.Select(item => _productRepository.GetByIdAsync(item.ProductId)).ToList();
    
    // Ждем завершения и обрабатываем результаты
    var customer = await customerTask;
    if (customer == null)
        return OrderResult.Failed("Customer not found");
        
    var products = await Task.WhenAll(productsTasks);
    if (products.Any(p => p == null))
        return OrderResult.Failed("One or more products not found");
        
    // Выполняем последовательные операции
    var order = _orderFactory.Create(customer, products, request);
    await _orderRepository.SaveAsync(order);
    
    // Запускаем фоновые операции и не ждем их завершения
    _ = _notificationService.SendOrderConfirmationAsync(order);
    
    return OrderResult.Success(order);
}

// Доменная модель - агрегат
public class ShoppingCart
{
    public Guid Id { get; private set; }
    public List<CartItem> Items { get; private set; } = new List<CartItem>();
    
    // Список событий, произошедших с агрегатом
    private readonly List<DomainEvent> _changes = new List<DomainEvent>();
    
    // Фабричный метод для создания корзины
    public static ShoppingCart Create(Guid customerId)
    {
        var cart = new ShoppingCart();
        cart.Apply(new CartCreatedEvent { CartId = Guid.NewGuid(), CustomerId = customerId });
        return cart;
    }
    
    // Добавление товара в корзину
    public void AddItem(Guid productId, int quantity, decimal price)
    {
        Apply(new ItemAddedToCartEvent
        {
            CartId = Id,
            ProductId = productId,
            Quantity = quantity,
            Price = price
        });
    }
    
    // Применение события к агрегату
    private void Apply(DomainEvent @event)
    {
        // Обновляем состояние агрегата на основе события
        When(@event);
        // Сохраняем событие для последующей записи
        _changes.Add(@event);
    }
    
    // Обработка различных типов событий
    private void When(DomainEvent @event)
    {
        switch (@event)
        {
            case CartCreatedEvent e:
                Id = e.CartId;
                break;
                
            case ItemAddedToCartEvent e:
                var existingItem = Items.FirstOrDefault(i => i.ProductId == e.ProductId);
                if (existingItem != null)
                {
                    existingItem.Quantity += e.Quantity;
                }
                else
                {
                    Items.Add(new CartItem
                    {
                        ProductId = e.ProductId,
                        Quantity = e.Quantity,
                        Price = e.Price
                    });
                }
                break;
                
            // Обработка других типов событий...
        }
    }
    
    // Получение списка непримененных событий
    public IEnumerable<DomainEvent> GetUncommittedChanges()
    {
        return _changes.AsReadOnly();
    }
    
    // Очистка списка непримененных событий
    public void MarkChangesAsCommitted()
    {
        _changes.Clear();
    }
}

// Антипаттерн: круговая зависимость
public class UserService {
    private readonly OrderService _orderService;
    
    public UserService(OrderService orderService) {
        _orderService = orderService;
    }
    
    // Методы...
}
 
public class OrderService {
    private readonly PaymentService _paymentService;
    
    public OrderService(PaymentService paymentService) {
        _paymentService = paymentService;
    }
    
    // Методы...
}
 
public class PaymentService {
    private readonly UserService _userService; // Круг замкнулся!
    
    public PaymentService(UserService userService) {
        _userService = userService;
    }
    
    // Методы...
}

// Ограниченный контекст "Заказы"
namespace OrderContext.Domain
{
    public class Order
    {
        public Guid Id { get; private set; }
        public OrderStatus Status { get; private set; }
        public Money TotalAmount { get; private set; }
        public List<OrderLine> Lines { get; private set; }
        
        // Бизнес-методы, специфичные для этого контекста
        public void AddProduct(Product product, int quantity)
        {
            // Логика добавления продукта в заказ
        }
        
        public void Submit()
        {
            // Бизнес-правила отправки заказа
        }
    }
}
 
// Ограниченный контекст "Доставка"
namespace ShippingContext.Domain
{
    public class Shipment
    {
        public Guid Id { get; private set; }
        public ShipmentStatus Status { get; private set; }
        public Address DeliveryAddress { get; private set; }
        public List<ShipmentItem> Items { get; private set; }
        
        // Бизнес-методы для контекста доставки
        public void MarkAsShipped(DateTime shippedAt)
        {
            // Логика отметки о доставке
        }
    }
}
 
// Слой трансляции между контекстами
namespace ContextMapping
{
    public class OrderToShipmentTranslator
    {
        public ShippingContext.Domain.Shipment TranslateOrder(OrderContext.Domain.Order order)
        {
            // Логика преобразования Order в Shipment
            // Важно: здесь происходит перевод между "языками" разных контекстов
        }
    }
}

// CQLinq-запрос для NDepend
from controller in Types.Where(t => t.NameLike("Controller"))
let repositories = Types.Where(t => t.NameLike("Repository"))
from repository in repositories
where controller.IsUsing(repository)
select new { controller, repository }

OrderManagement/
├── OrderManagement.Api/           # API слой
├── OrderManagement.Application/   # Слой приложения (сценарии использования)
├── OrderManagement.Domain/        # Доменный слой (модели, бизнес-логика)
├── OrderManagement.Infrastructure/ # Инфраструктурный слой
└── OrderManagement.EventStore/    # Реализация хранилища событий

Domain/
├── Orders/                # Ограниченный контекст заказов
│   ├── Order.cs           # Агрегат
│   ├── OrderLine.cs       # Сущность внутри агрегата
│   ├── OrderId.cs         # Value Object
│   └── Events/            # Доменные события
│       ├── OrderCreated.cs
│       ├── ProductAdded.cs
│       └── ...
├── Customers/             # Другой ограниченный контекст
└── Products/              # Еще один контекст

// Команда (изменение состояния)
public class CreateOrderCommand : ICommand
{
    public Guid CustomerId { get; set; }
    public List<OrderLineDto> Items { get; set; }
}
 
// Обработчик команды
public class CreateOrderHandler : ICommandHandler<CreateOrderCommand>
{
    private readonly IEventStore _eventStore;
    
    public CreateOrderHandler(IEventStore eventStore)
    {
        _eventStore = eventStore;
    }
    
    public async Task Handle(CreateOrderCommand command, CancellationToken token)
    {
        // Создаем новый агрегат
        var order = Order.Create(
            OrderId.New(), 
            new CustomerId(command.CustomerId),
            command.Items.Select(i => new OrderLine(
                new ProductId(i.ProductId),
                i.Quantity,
                Money.FromDecimal(i.Price)
            )).ToList()
        );
        
        // Сохраняем события
        await _eventStore.SaveEvents(order.Id, order.GetUncommittedEvents(), -1);
        
        // Очищаем список несохраненных событий
        order.ClearUncommittedEvents();
    }
}
 
// Запрос (чтение данных)
public class GetOrderDetailsQuery : IQuery<OrderDetailsDto>
{
    public Guid OrderId { get; set; }
}
 
// Обработчик запроса
public class GetOrderDetailsHandler : IQueryHandler<GetOrderDetailsQuery, OrderDetailsDto>
{
    private readonly IOrderReadRepository _repository;
    
    public GetOrderDetailsHandler(IOrderReadRepository repository)
    {
        _repository = repository;
    }
    
    public async Task<OrderDetailsDto> Handle(GetOrderDetailsQuery query, CancellationToken token)
    {
        // Используем отдельную оптимизированную для чтения модель
        return await _repository.GetOrderDetailsAsync(query.OrderId);
    }
}

public class Order : AggregateRoot
{
    public OrderId Id { get; private set; }
    public CustomerId CustomerId { get; private set; }
    public OrderStatus Status { get; private set; }
    public List<OrderLine> Lines { get; private set; }
    
    // Фабричный метод для создания нового заказа
    public static Order Create(OrderId id, CustomerId customerId, List<OrderLine> lines)
    {
        var order = new Order();
        // Генерируем событие
        order.ApplyEvent(new OrderCreatedEvent(id, customerId, lines));
        return order;
    }
    
    // Добавление продукта в заказ
    public void AddProduct(ProductId productId, int quantity, Money price)
    {
        if (Status != OrderStatus.Draft)
            throw new InvalidOperationException("Can only add products to a draft order");
        
        ApplyEvent(new ProductAddedEvent(Id, productId, quantity, price));
    }
    
    // Применение событий к агрегату
    protected override void ApplyEvent(DomainEvent @event)
    {
        switch (@event)
        {
            case OrderCreatedEvent e:
                Id = new OrderId(e.OrderId);
                CustomerId = new CustomerId(e.CustomerId);
                Status = OrderStatus.Draft;
                Lines = e.Lines.Select(l => new OrderLine(
                    new ProductId(l.ProductId),
                    l.Quantity,
                    Money.FromDecimal(l.Price)
                )).ToList();
                break;
                
            case ProductAddedEvent e:
                var existingLine = Lines.FirstOrDefault(l => l.ProductId == new ProductId(e.ProductId));
                if (existingLine != null)
                {
                    existingLine.IncreaseQuantity(e.Quantity);
                }
                else
                {
                    Lines.Add(new OrderLine(
                        new ProductId(e.ProductId),
                        e.Quantity,
                        Money.FromDecimal(e.Price)
                    ));
                }
                break;
                
            // Обработка других событий...
        }
    }
}