Шаблоны и приёмы реализации DDD на C#

// Традиционный подход
public class Usr {
    public int Id { get; set; }
    public string FName { get; set; }
    public string LName { get; set; }
    public DateTime DOB { get; set; }
    public bool IsActive { get; set; }
}
 
// DDD подход
public class Customer {
    public CustomerId Id { get; private set; }
    public FullName Name { get; private set; }
    public DateOfBirth BirthDate { get; private set; }
    public bool IsActive { get; private set; }
    
    public void Deactivate() {
        // Бизнес-логика деактивации клиента
        IsActive = false;
    }
}

// C# 9.0 record для объекта-значения
public record Money(decimal Amount, string Currency)
{
    public Money Add(Money other)
    {
        if (other.Currency != Currency)
            throw new InvalidOperationException("Нельзя складывать деньги в разных валютах");
        
        return this with { Amount = Amount + other.Amount };
    }
}

public class OrderPlaced : IDomainEvent
{
    public Guid OrderId { get; }
    public Guid CustomerId { get; }
    public decimal TotalAmount { get; }
    public DateTime OccurredOn { get; }
 
    public OrderPlaced(Guid orderId, Guid customerId, decimal totalAmount)
    {
        OrderId = orderId;
        CustomerId = customerId;
        TotalAmount = totalAmount;
        OccurredOn = DateTime.UtcNow;
    }
}

// Без единого языка
public class OrdItemManager {
    public void ProcItems(List<OrdItem> items) {
        foreach (var item in items) {
            if (item.Qty > 0 && item.Status != 3) {
                // Логика обработки...
            }
        }
    }
}
 
// С единым языком
public class OrderLineProcessor {
    public void ProcessPendingOrderLines(List<OrderLine> orderLines) {
        foreach (var line in orderLines) {
            if (line.Quantity > 0 && line.Status != OrderLineStatus.Canceled) {
                // Логика обработки...
            }
        }
    }
}

namespace Ecommerce.Catalog {
    public class Product {
        public string Name { get; private set; }
        public string Description { get; private set; }
        public decimal Price { get; private set; }
        // Атрибуты и методы, релевантные для каталога
    }
}
 
namespace Ecommerce.Warehouse {
    public class Product {
        public string SKU { get; private set; }
        public int StockLevel { get; private set; }
        public string StorageLocation { get; private set; }
        // Атрибуты и методы, релевантные для склада
    }
}

public class Order // Корень агрегата
{
    private readonly List<OrderLine> _orderLines = new List<OrderLine>();
    
    public IReadOnlyCollection<OrderLine> OrderLines => _orderLines.AsReadOnly();
    
    public void AddProduct(Product product, int quantity)
    {
        // Проверка бизнес-правил перед добавлением
        if (IsLocked)
            throw new OrderLockedException("Нельзя изменять заблокированный заказ");
        
        var existingLine = _orderLines.FirstOrDefault(ol => ol.ProductId == product.Id);
        if (existingLine != null)
        {
            existingLine.IncreaseQuantity(quantity);
        }
        else
        {
            _orderLines.Add(new OrderLine(product.Id, quantity, product.Price));
        }
    }
}

public class Customer
{
    public Guid Id { get; private set; }
    public string FullName { get; private set; }
    public Address HomeAddress { get; private set; }
    
    // Конструктор, методы и прочее
    
    public override bool Equals(object obj)
    {
        if (obj is not Customer other) return false;
        return Id == other.Id; // Сравнение только по ID
    }
    
    public override int GetHashCode() => Id.GetHashCode();
}

public class Address : IEquatable<Address>
{
    public string Street { get; }
    public string City { get; }
    public string ZipCode { get; }
    
    public Address(string street, string city, string zipCode)
    {
        // Валидация
        Street = street;
        City = city;
        ZipCode = zipCode;
    }
    
    public bool Equals(Address other)
    {
        if (other is null) return false;
        return Street == other.Street && 
               City == other.City && 
               ZipCode == other.ZipCode;
    }
    
    public override bool Equals(object obj) => Equals(obj as Address);
    public override int GetHashCode() => 
        HashCode.Combine(Street, City, ZipCode);
}

public record Money(decimal Amount, string Currency)
{
    public Money Add(Money other)
    {
        if (other.Currency != Currency)
            throw new InvalidOperationException("Валюты должны совпадать");
        
        return this with { Amount = Amount + other.Amount };
    }
    
    public Money Subtract(Money other)
    {
        if (other.Currency != Currency)
            throw new InvalidOperationException("Валюты должны совпадать");
        
        return this with { Amount = Amount - other.Amount };
    }
}

public class Order // Корень агрегата
{
    private readonly List<OrderLine> _orderLines = new();
    private bool _isSubmitted;
    
    public Guid Id { get; private set; }
    public CustomerId CustomerId { get; private set; }
    public IReadOnlyCollection<OrderLine> OrderLines => _orderLines.AsReadOnly();
    public OrderStatus Status { get; private set; }
    
    public Order(CustomerId customerId)
    {
        Id = Guid.NewGuid();
        CustomerId = customerId;
        Status = OrderStatus.Draft;
    }
    
    public void AddProduct(ProductId productId, int quantity, Money unitPrice)
    {
        if (_isSubmitted)
            throw new OrderAlreadySubmittedException($"Заказ {Id} уже подтвержден и не может быть изменен.");
        
        if (quantity <= 0)
            throw new InvalidQuantityException("Количество должно быть положительным числом");
        
        var existingLine = _orderLines.FirstOrDefault(line => line.ProductId == productId);
        if (existingLine != null)
        {
            _orderLines.Remove(existingLine);
            _orderLines.Add(existingLine.WithQuantity(existingLine.Quantity + quantity));
        }
        else
        {
            _orderLines.Add(new OrderLine(productId, quantity, unitPrice));
        }
    }
    
    public void Submit()
    {
        if (_isSubmitted)
            throw new OrderAlreadySubmittedException($"Заказ {Id} уже подтвержден.");
        
        if (!_orderLines.Any())
            throw new EmptyOrderException("Невозможно подтвердить пустой заказ");
        
        _isSubmitted = true;
        Status = OrderStatus.Submitted;
        
        // Здесь может быть логика добавления доменного события
    }
}

public static class Guard
{
    public static void AgainstNegativeOrZero(int value, string paramName)
    {
        if (value <= 0)
            throw new ArgumentException($"{paramName} должен быть положительным числом", paramName);
    }
    
    public static void AgainstNullOrEmpty(string value, string paramName)
    {
        if (string.IsNullOrEmpty(value))
            throw new ArgumentException($"{paramName} не может быть пустым", paramName);
    }
}
 
// Использование
public void AddProduct(ProductId productId, int quantity, Money unitPrice)
{
    Guard.AgainstNegativeOrZero(quantity, nameof(quantity));
    // Остальная логика...
}

public class NegativeQuantityException : DomainException
{
    public NegativeQuantityException(int quantity) 
        : base($"Количество {quantity} не может быть отрицательным") { }
}
 
public abstract class DomainException : Exception
{
    protected DomainException(string message) : base(message) { }
}

public record UserId
{
    public Guid Value { get; }
    
    private UserId(Guid value) => Value = value;
    
    public static UserId Create() => new(Guid.NewGuid());
    public static UserId FromGuid(Guid guid) => new(guid);
    
    public static implicit operator Guid(UserId userId) => userId.Value;
    public static implicit operator UserId(Guid guid) => new(guid);
    
    public override string ToString() => Value.ToString();
}
 
// Использование
public void AssignTask(UserId assignee)
{
    // Методы...
}
 
// Можно вызвать так
Guid guid = Guid.NewGuid();
service.AssignTask(guid); // Неявное преобразование Guid в UserId

// Базовый класс для всех доменных исключений
public abstract class DomainException : Exception
{
    protected DomainException(string message) : base(message) { }
}
 
// Базовый класс для нарушений бизнес-правил
public abstract class BusinessRuleViolationException : DomainException
{
    protected BusinessRuleViolationException(string message) : base(message) { }
}
 
// Конкретное исключение
public class InsufficientFundsException : BusinessRuleViolationException
{
    public InsufficientFundsException(Money available, Money required) 
        : base($"Недостаточно средств. Доступно: {available}, Требуется: {required}") { }
}

public class Order
{
    private readonly Lazy<List<OrderLine>> _orderLines;
    
    public Order(IOrderLinesRepository repository)
    {
        _orderLines = new Lazy<List<OrderLine>>(() => 
            repository.GetLinesForOrder(Id).ToList());
    }
    
    public IReadOnlyCollection<OrderLine> OrderLines => _orderLines.Value.AsReadOnly();
}

// Запрос через проекцию
public IEnumerable<OrderSummary> GetOrderSummaries(CustomerId customerId)
{
    return _dbContext.Orders
        .Where(o => o.CustomerId == customerId)
        .Select(o => new OrderSummary
        {
            Id = o.Id,
            Date = o.CreatedAt,
            Total = o.OrderLines.Sum(ol => ol.Quantity * ol.UnitPrice),
            Status = o.Status
        })
        .ToList();
}

public class CachedProductRepository : IProductRepository
{
    private readonly IProductRepository _innerRepository;
    private readonly IMemoryCache _cache;
    
    public async Task<Product> GetByIdAsync(ProductId id)
    {
        string cacheKey = $"Product_{id}";
        if (!_cache.TryGetValue(cacheKey, out Product product))
        {
            product = await _innerRepository.GetByIdAsync(id);
            _cache.Set(cacheKey, product, TimeSpan.FromMinutes(10));
        }
        return product;
    }
}

// Базовое исключение для всего домена
public abstract class DomainException : Exception
{
    protected DomainException(string message) : base(message) {}
}
 
// Нарушение бизнес-правил
public class BusinessRuleViolationException : DomainException
{
    public BusinessRuleViolationException(string rule) 
        : base($"Нарушено бизнес-правило: {rule}") {}
}
 
// Недействительное состояние агрегата
public class InvalidAggregateStateException : DomainException
{
    public InvalidAggregateStateException(string aggregate, string expectedState, string actualState) 
        : base($"Агрегат {aggregate} находится в состоянии {actualState}, но ожидалось {expectedState}") {}
}
 
// Сущность не найдена
public class EntityNotFoundException : DomainException
{
    public EntityNotFoundException(string entityType, object id) 
        : base($"Сущность {entityType} с идентификатором {id} не найдена") {}
}

public class Result<T>
{
    public bool IsSuccess { get; }
    public T Value { get; }
    public string Error { get; }
    public bool IsFailure => !IsSuccess;
    
    private Result(bool isSuccess, T value, string error)
    {
        IsSuccess = isSuccess;
        Value = value;
        Error = error;
    }
    
    public static Result<T> Success(T value) => new Result<T>(true, value, null);
    public static Result<T> Failure(string error) => new Result<T>(false, default, error);
}
 
// Использование
public Result<Order> PlaceOrder(CustomerId customerId, IEnumerable<OrderItem> items)
{
    // Проверка наличия товаров
    foreach (var item in items)
    {
        if (!_inventoryService.IsInStock(item.ProductId, item.Quantity))
            return Result<Order>.Failure($"Товар {item.ProductId} отсутствует в нужном количестве");
    }
    
    // Создание заказа
    var order = new Order(customerId);
    foreach (var item in items)
    {
        order.AddProduct(item.ProductId, item.Quantity, item.UnitPrice);
    }
    
    _orderRepository.Add(order);
    return Result<Order>.Success(order);
}

public static class Contract
{
    public static void Requires<TException>(bool condition, string message = null) 
        where TException : Exception, new()
    {
        if (!condition)
        {
            if (string.IsNullOrEmpty(message))
                throw Activator.CreateInstance<TException>();
            
            throw (Exception)Activator.CreateInstance(typeof(TException), message);
        }
    }
}
 
// Использование
public void Transfer(Account target, Money amount)
{
    Contract.Requires<ArgumentNullException>(target != null, "Целевой счет не может быть null");
    Contract.Requires<ArgumentException>(amount.Amount > 0, "Сумма должна быть положительной");
    Contract.Requires<InsufficientFundsException>(Balance.Amount >= amount.Amount, 
        "Недостаточно средств для перевода");
    
    Balance = Balance.Subtract(amount);
    target.Balance = target.Balance.Add(amount);
}

public interface IOrderPolicy
{
    bool CanSubmit(Order order);
    bool CanCancel(Order order);
    bool CanAddProduct(Order order, Product product, int quantity);
}
 
public class StandardOrderPolicy : IOrderPolicy
{
    private readonly ISpecification<Order> _submittableOrderSpec;
    private readonly ISpecification<Order> _cancellableOrderSpec;
    
    public StandardOrderPolicy(
        ISpecification<Order> submittableOrderSpec,
        ISpecification<Order> cancellableOrderSpec)
    {
        _submittableOrderSpec = submittableOrderSpec;
        _cancellableOrderSpec = cancellableOrderSpec;
    }
    
    public bool CanSubmit(Order order) => _submittableOrderSpec.IsSatisfiedBy(order);
    public bool CanCancel(Order order) => _cancellableOrderSpec.IsSatisfiedBy(order);
    
    public bool CanAddProduct(Order order, Product product, int quantity)
    {
        return !order.IsSubmitted && quantity > 0 && product.IsActive;
    }
}

public interface IRepository<T, TId> where T : IAggregateRoot
{
    Task<T> GetByIdAsync(TId id);
    Task<IEnumerable<T>> GetAllAsync();
    Task AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(TId id);
}
 
public interface IOrderRepository : IRepository<Order, Guid>
{
    Task<IEnumerable<Order>> GetByCustomerIdAsync(Guid customerId);
    Task<IEnumerable<Order>> GetPendingOrdersAsync();
}

public interface IOrderRepository
{
    Task<Order> GetByIdAsync(OrderId id);
    Task<IEnumerable<Order>> GetByCustomerIdAsync(CustomerId customerId);
    Task<IEnumerable<Order>> GetPendingOrdersAsync();
    Task AddAsync(Order order);
    Task UpdateAsync(Order order);
}

public interface IPaymentService
{
    Task<Result<TransactionId>> TransferMoneyAsync(
        AccountId sourceAccountId, 
        AccountId targetAccountId, 
        Money amount);
}
 
public class PaymentService : IPaymentService
{
    private readonly IAccountRepository _accountRepository;
    private readonly ITransactionRepository _transactionRepository;
 
    public PaymentService(
        IAccountRepository accountRepository,
        ITransactionRepository transactionRepository)
    {
        _accountRepository = accountRepository;
        _transactionRepository = transactionRepository;
    }
 
    public async Task<Result<TransactionId>> TransferMoneyAsync(
        AccountId sourceAccountId, 
        AccountId targetAccountId, 
        Money amount)
    {
        var sourceAccount = await _accountRepository.GetByIdAsync(sourceAccountId);
        var targetAccount = await _accountRepository.GetByIdAsync(targetAccountId);
 
        if (sourceAccount == null)
            return Result<TransactionId>.Failure("Исходный счёт не найден");
            
        if (targetAccount == null)
            return Result<TransactionId>.Failure("Целевой счёт не найден");
 
        if (!sourceAccount.CanWithdraw(amount))
            return Result<TransactionId>.Failure("Недостаточно средств");
 
        sourceAccount.Withdraw(amount);
        targetAccount.Deposit(amount);
 
        await _accountRepository.UpdateAsync(sourceAccount);
        await _accountRepository.UpdateAsync(targetAccount);
 
        var transaction = new Transaction(sourceAccountId, targetAccountId, amount);
        await _transactionRepository.AddAsync(transaction);
 
        return Result<TransactionId>.Success(transaction.Id);
    }
}

public interface IOrderFactory
{
    Order CreateOrder(CustomerId customerId, IEnumerable<OrderLineDto> orderLines);
}
 
public class OrderFactory : IOrderFactory
{
    private readonly IProductRepository _productRepository;
 
    public OrderFactory(IProductRepository productRepository)
    {
        _productRepository = productRepository;
    }
 
    public Order CreateOrder(CustomerId customerId, IEnumerable<OrderLineDto> orderLines)
    {
        var order = new Order(customerId);
        
        foreach (var line in orderLines)
        {
            var product = _productRepository.GetByIdAsync(line.ProductId).Result;
            if (product == null)
                throw new ProductNotFoundException(line.ProductId);
                
            order.AddProduct(product.Id, line.Quantity, product.Price);
        }
        
        return order;
    }
}

public interface ISpecification<T>
{
    bool IsSatisfiedBy(T entity);
    Expression<Func<T, bool>> ToExpression();
}
 
public class OverdueInvoiceSpecification : ISpecification<Invoice>
{
    private readonly DateTime _currentDate;
 
    public OverdueInvoiceSpecification(DateTime? currentDate = null)
    {
        _currentDate = currentDate ?? DateTime.UtcNow;
    }
 
    public bool IsSatisfiedBy(Invoice invoice)
    {
        return invoice.DueDate < _currentDate && !invoice.IsPaid;
    }
 
    public Expression<Func<Invoice, bool>> ToExpression()
    {
        return invoice => invoice.DueDate < _currentDate && !invoice.IsPaid;
    }
}

public class AndSpecification<T> : ISpecification<T>
{
    private readonly ISpecification<T> _left;
    private readonly ISpecification<T> _right;
 
    public AndSpecification(ISpecification<T> left, ISpecification<T> right)
    {
        _left = left;
        _right = right;
    }
 
    public bool IsSatisfiedBy(T entity)
    {
        return _left.IsSatisfiedBy(entity) && _right.IsSatisfiedBy(entity);
    }
 
    public Expression<Func<T, bool>> ToExpression()
    {
        var leftExpression = _left.ToExpression();
        var rightExpression = _right.ToExpression();
        
        var paramExpr = Expression.Parameter(typeof(T));
        var bodyExpr = Expression.AndAlso(
            Expression.Invoke(leftExpression, paramExpr),
            Expression.Invoke(rightExpression, paramExpr)
        );
        
        return Expression.Lambda<Func<T, bool>>(bodyExpr, paramExpr);
    }
}
 
// Использование
var overdueHighValueSpec = new AndSpecification<Invoice>(
    new OverdueInvoiceSpecification(),
    new HighValueInvoiceSpecification(1000)
);
 
var overdueHighValueInvoices = await _invoiceRepository.FindAsync(overdueHighValueSpec);

public class OrderStateMachine
{
    private static readonly Dictionary<OrderStatus, IEnumerable<OrderStatus>> _allowedTransitions =
        new Dictionary<OrderStatus, IEnumerable<OrderStatus>>
        {
            { OrderStatus.Draft, new[] { OrderStatus.Submitted } },
            { OrderStatus.Submitted, new[] { OrderStatus.Paid, OrderStatus.Cancelled } },
            { OrderStatus.Paid, new[] { OrderStatus.Shipped, OrderStatus.Refunded } },
            { OrderStatus.Shipped, new[] { OrderStatus.Delivered, OrderStatus.Returned } },
            { OrderStatus.Delivered, new[] { OrderStatus.Closed, OrderStatus.Returned } },
            { OrderStatus.Returned, new[] { OrderStatus.Refunded, OrderStatus.Closed } },
            { OrderStatus.Refunded, new[] { OrderStatus.Closed } },
            { OrderStatus.Cancelled, new[] { OrderStatus.Closed } },
            { OrderStatus.Closed, new OrderStatus[0] },
        };
 
    public bool CanTransitionTo(OrderStatus currentStatus, OrderStatus newStatus)
    {
        return _allowedTransitions.ContainsKey(currentStatus) && 
               _allowedTransitions[currentStatus].Contains(newStatus);
    }
 
    public void EnsureValidTransition(OrderStatus currentStatus, OrderStatus newStatus)
    {
        if (!CanTransitionTo(currentStatus, newStatus))
        {
            throw new InvalidStateTransitionException(
                $"Переход из {currentStatus} в {newStatus} невозможен");
        }
    }
}

public class Order
{
    private readonly OrderStateMachine _stateMachine = new OrderStateMachine();
    
    public OrderStatus Status { get; private set; }
    
    public void Submit()
    {
        _stateMachine.EnsureValidTransition(Status, OrderStatus.Submitted);
        Status = OrderStatus.Submitted;
        // Дополнительная логика...
    }
    
    public void MarkAsPaid()
    {
        _stateMachine.EnsureValidTransition(Status, OrderStatus.Paid);
        Status = OrderStatus.Paid;
        // Дополнительная логика...
    }
    
    // Другие методы перехода между состояниями...
}

public interface IOrderRepository
{
    Task<Order> GetByIdAsync(OrderId id);
    Task<IReadOnlyCollection<Order>> GetPendingOrdersForCustomerAsync(CustomerId customerId);
    Task<bool> HasActiveOrdersAsync(CustomerId customerId);
    Task AddAsync(Order order);
    Task UpdateAsync(Order order);
}

public interface IOrderCommandRepository
{
    Task AddAsync(Order order);
    Task UpdateAsync(Order order);
    Task DeleteAsync(OrderId id);
}
 
public interface IOrderQueryRepository
{
    Task<Order> GetByIdAsync(OrderId id);
    Task<PagedResult<OrderSummary>> GetPaginatedOrdersAsync(
        CustomerId customerId, int page, int pageSize);
    Task<bool> HasActiveOrdersAsync(CustomerId customerId);
}

public static class DomainServiceCollectionExtensions
{
    public static IServiceCollection AddDomainServices(this IServiceCollection services)
    {
        // Сервисы домена
        services.AddScoped<IOrderService, OrderService>();
        services.AddScoped<IPaymentService, PaymentService>();
        
        // Репозитории
        services.AddScoped<IOrderRepository, OrderRepository>();
        services.AddScoped<ICustomerRepository, CustomerRepository>();
        
        // Фабрики
        services.AddScoped<IOrderFactory, OrderFactory>();
        
        // Спецификации
        services.AddScoped<ISpecificationFactory, SpecificationFactory>();
        
        return services;
    }
}

public static IServiceCollection AddDomainServices(this IServiceCollection services)
{
    var domainAssembly = typeof(Order).Assembly;
    
    // Автоматическая регистрация всех сервисов домена
    var serviceTypes = domainAssembly.GetTypes()
        .Where(t => t.IsClass && !t.IsAbstract && t.Name.EndsWith("Service"))
        .Where(t => t.GetInterfaces().Any(i => i.Name == $"I{t.Name}"));
        
    foreach (var serviceType in serviceTypes)
    {
        var interfaceType = serviceType.GetInterfaces()
            .First(i => i.Name == $"I{serviceType.Name}");
        services.AddScoped(interfaceType, serviceType);
    }
    
    return services;
}

public interface IProductRecommendationService
{
    Task<IReadOnlyCollection<ProductId>> GetRecommendationsForCustomerAsync(
        CustomerId customerId, int maxRecommendations = 5);
}
 
public class MlProductRecommendationAdapter : IProductRecommendationService
{
    private readonly IRecommendationApiClient _apiClient;
    private readonly ICustomerRepository _customerRepository;
    
    public MlProductRecommendationAdapter(
        IRecommendationApiClient apiClient,
        ICustomerRepository customerRepository)
    {
        _apiClient = apiClient;
        _customerRepository = customerRepository;
    }
    
    public async Task<IReadOnlyCollection<ProductId>> GetRecommendationsForCustomerAsync(
        CustomerId customerId, int maxRecommendations = 5)
    {
        var customer = await _customerRepository.GetByIdAsync(customerId);
        if (customer == null)
            return Array.Empty<ProductId>();
            
        // Преобразование доменной модели в формат, понятный ML-сервису
        var features = ExtractFeaturesFromCustomer(customer);
        
        // Получение рекомендаций от ML-сервиса
        var recommendations = await _apiClient.GetRecommendationsAsync(features, maxRecommendations);
        
        // Преобразование результатов обратно в доменные объекты
        return recommendations.Select(r => new ProductId(r.ProductGuid)).ToList();
    }
    
    private CustomerFeatures ExtractFeaturesFromCustomer(Customer customer)
    {
        // Извлечение признаков из доменной модели для ML-модели
        return new CustomerFeatures
        {
            Age = customer.CalculateAge(),
            PurchaseHistory = customer.Orders.Select(o => o.Id.Value).ToArray(),
            PreferredCategories = customer.Preferences.FavoriteCategories.ToArray()
        };
    }
}

// Приёмная комиссия
namespace University.Admissions
{
    public class Applicant
    {
        public Guid Id { get; private set; }
        public string FullName { get; private set; }
        public DateTime DateOfBirth { get; private set; }
        public List<Document> Documents { get; private set; }
        public ApplicationStatus Status { get; private set; }
        
        // Методы для работы с заявлением
    }
}
 
// Учебный отдел
namespace University.Academic
{
    public class Student
    {
        public Guid Id { get; private set; }
        public string FullName { get; private set; }
        public Faculty Faculty { get; private set; }
        public int Year { get; private set; }
        public List<Course> EnrolledCourses { get; private set; }
        public AcademicPerformance Performance { get; private set; }
        
        // Методы для работы с учебным процессом
    }
}
 
// Бухгалтерия
namespace University.Accounting
{
    public class Payer
    {
        public Guid Id { get; private set; }
        public string FullName { get; private set; }
        public List<Invoice> Invoices { get; private set; }
        public PaymentStatus Status { get; private set; }
        
        // Методы для работы с оплатами
    }
}

// Внешняя модель из устаревшей системы
public class LegacyCustomerDto
{
    public int CustId { get; set; }
    public string FName { get; set; }
    public string LName { get; set; }
    public string Addr { get; set; }
    public string City { get; set; }
    public string Zip { get; set; }
    public byte Status { get; set; } // 0 - inactive, 1 - active
}
 
// Антикоррупционный слой
public class LegacyCustomerAdapter : ICustomerRepository
{
    private readonly ILegacyCustomerApi _legacyApi;
    
    public async Task<Customer> GetByIdAsync(CustomerId id)
    {
        var legacyCustomer = await _legacyApi.GetCustomerById(int.Parse(id.Value));
        
        if (legacyCustomer == null)
            return null;
            
        // Трансформация из устаревшей модели в нашу доменную модель
        var address = new Address(legacyCustomer.Addr, legacyCustomer.City, legacyCustomer.Zip);
        var name = new PersonName(legacyCustomer.FName, legacyCustomer.LName);
        var isActive = legacyCustomer.Status == 1;
        
        return new Customer(
            CustomerId.FromString(legacyCustomer.CustId.ToString()),
            name,
            address,
            isActive
        );
    }
    
    // Другие методы репозитория...
}

[BoundedContext("Marketing")]
public class Campaign
{
    // Содержимое класса...
}

// Доменное событие
public record OrderPlacedEvent : IDomainEvent
{
    public Guid OrderId { get; }
    public Guid CustomerId { get; }
    public decimal TotalAmount { get; }
    public DateTime OccurredOn { get; }
    
    public OrderPlacedEvent(Guid orderId, Guid customerId, decimal totalAmount)
    {
        OrderId = orderId;
        CustomerId = customerId;
        TotalAmount = totalAmount;
        OccurredOn = DateTime.UtcNow;
    }
}
 
// Публикатор событий с использованием MassTransit
public class MassTransitEventPublisher : IDomainEventPublisher
{
    private readonly IBus _bus;
    
    public MassTransitEventPublisher(IBus bus)
    {
        _bus = bus;
    }
    
    public async Task PublishAsync<TEvent>(TEvent domainEvent) where TEvent : IDomainEvent
    {
        await _bus.Publish(domainEvent);
    }
}
 
// Потребитель события в другом контексте
public class OrderPlacedEventConsumer : IConsumer<OrderPlacedEvent>
{
    private readonly IShippingService _shippingService;
    
    public OrderPlacedEventConsumer(IShippingService shippingService)
    {
        _shippingService = shippingService;
    }
    
    public async Task Consume(ConsumeContext<OrderPlacedEvent> context)
    {
        var orderId = context.Message.OrderId;
        
        // Обработка события в контексте доставки
        await _shippingService.InitializeShippingProcessAsync(orderId);
    }
}

public class OrderProcessOrchestrator
{
    private readonly IOrderService _orderService;
    private readonly IPaymentService _paymentService;
    private readonly IInventoryService _inventoryService;
    private readonly IShippingService _shippingService;
    
    public async Task ProcessOrderAsync(Guid orderId)
    {
        // 1. Проверка и бронирование товаров
        var reservationResult = await _inventoryService.ReserveItemsAsync(orderId);
        if (!reservationResult.IsSuccess)
            return; // Обработка ошибки
        
        // 2. Обработка платежа
        var paymentResult = await _paymentService.ProcessPaymentAsync(orderId);
        if (!paymentResult.IsSuccess)
        {
            // Откат бронирования товаров
            await _inventoryService.CancelReservationAsync(orderId);
            return;
        }
        
        // 3. Подтверждение заказа
        await _orderService.ConfirmOrderAsync(orderId);
        
        // 4. Инициализация доставки
        await _shippingService.InitializeShippingAsync(orderId);
    }
}

// В контексте заказов
public class OrderPlacedEventConsumer : IConsumer<OrderPlacedEvent>
{
    private readonly IInventoryService _inventoryService;
    
    public async Task Consume(ConsumeContext<OrderPlacedEvent> context)
    {
        await _inventoryService.ReserveItemsAsync(context.Message.OrderId);
    }
}
 
// В контексте инвентаря
public class ItemsReservedEventConsumer : IConsumer<ItemsReservedEvent>
{
    private readonly IPaymentService _paymentService;
    
    public async Task Consume(ConsumeContext<ItemsReservedEvent> context)
    {
        await _paymentService.ProcessPaymentAsync(context.Message.OrderId);
    }
}
 
// И так далее...

// Команда - изменение состояния
public class UpdateCustomerAddressCommand : ICommand
{
public Guid CustomerId { get; set; }
public AddressDto NewAddress { get; set; }
}
 
// Обработчик команды - использует доменную модель
public class UpdateCustomerAddressCommandHandler : ICommandHandler<UpdateCustomerAddressCommand>
{
private readonly ICustomerRepository _repository;
 
public async Task HandleAsync(UpdateCustomerAddressCommand command)
{
    var customer = await _repository.GetByIdAsync(new CustomerId(command.CustomerId));
    
    var address = new Address(
        command.NewAddress.Street,
        command.NewAddress.City,
        command.NewAddress.State,
        command.NewAddress.ZipCode
    );
    
    customer.UpdateAddress(address);
    await _repository.UpdateAsync(customer);
}
}
 
// Запрос - получение данных
public class GetCustomerDetailsQuery : IQuery<CustomerDetailsDto>
{
public Guid CustomerId { get; set; }
}
 
// Обработчик запроса - использует оптимизированое хранилище для чтения
public class GetCustomerDetailsQueryHandler : IQueryHandler<GetCustomerDetailsQuery, CustomerDetailsDto>
{
private readonly ICustomerReadDbContext _readDb;
 
public async Task<CustomerDetailsDto> HandleAsync(GetCustomerDetailsQuery query)
{
    // Прямой запрос к БД для чтения, минуя доменную модель
    return await _readDb.Customers
        .Where(c => c.Id == query.CustomerId)
        .Select(c => new CustomerDetailsDto
        {
            Id = c.Id,
            FullName = c.FirstName + " " + c.LastName,
            EmailAddress = c.Email,
            Address = new AddressDto
            {
                Street = c.Street,
                City = c.City,
                State = c.State,
                ZipCode = c.ZipCode
            }
        })
        .FirstOrDefaultAsync();
}
}

public class Customer : EventSourcedAggregateRoot
{
private string _name;
private Address _address;
private bool _isActive;
 
public void UpdateAddress(Address newAddress)
{
    if (!_isActive)
        throw new CustomerInactiveException(Id);
        
    ApplyChange(new CustomerAddressUpdatedEvent(Id, newAddress));
}
 
private void Apply(CustomerAddressUpdatedEvent @event)
{
    _address = new Address(
        @event.Street,
        @event.City,
        @event.State,
        @event.ZipCode
    );
}
}

[Fact]
public void Customer_CannotPlaceOrder_WhenInactive()
{
// Arrange
var customer = new Customer("John Doe", "john@example.com");
customer.Deactivate();
 
// Act & Assert
Assert.Throws<CustomerInactiveException>(() => 
    customer.PlaceOrder(
        new List<OrderItem> { new OrderItem("Product1", 2, new Money(100, "USD")) }
    )
);
}