Domain-Driven Design in C#: Tactical and Strategic Patterns

namespace Shop.Sales.Domain.Orders;

public interface IDomainEvent
{
    DateTimeOffset OccurredAt { get; }
}

public interface IHasDomainEvents
{
    IReadOnlyCollection<IDomainEvent> DomainEvents { get; }
    void ClearDomainEvents();
}

public abstract class AggregateRoot<TId> : IHasDomainEvents where TId : struct
{
    private readonly List<IDomainEvent> _domainEvents = [];

    public TId Id { get; protected init; }
    public IReadOnlyCollection<IDomainEvent> DomainEvents => _domainEvents.AsReadOnly();

    protected void Raise(IDomainEvent domainEvent) => _domainEvents.Add(domainEvent);
    public void ClearDomainEvents() => _domainEvents.Clear();
}

public sealed record OrderPlaced(
    OrderId OrderId, CustomerId CustomerId, Money Total, DateTimeOffset OccurredAt)
    : IDomainEvent;

public sealed class Order : AggregateRoot<OrderId>
{
    public const int MaxDistinctItems = 50;
    private readonly List<OrderLine> _lines = [];

    private Order() { } // For EF Core.

    private Order(CustomerId customerId, Address shippingAddress, string currency)
    {
        Id = OrderId.New();
        CustomerId = customerId;
        ShippingAddress = shippingAddress;
        Currency = currency;
        Discount = Money.Zero(currency);
    }

    public CustomerId CustomerId { get; private set; }
    public Address ShippingAddress { get; private set; } = null!;
    public string Currency { get; private set; } = null!;
    public Money Discount { get; private set; } = null!;
    public OrderStatus Status { get; private set; } = OrderStatus.Draft;
    public IReadOnlyCollection<OrderLine> Lines => _lines.AsReadOnly();

    public Money Subtotal =>
        _lines.Aggregate(Money.Zero(Currency), (sum, line) => sum.Add(line.Subtotal));
    public Money Total => Subtotal.Subtract(Discount);

    public static Order Start(CustomerId customerId, Address shippingAddress, string currency) =>
        new(customerId, shippingAddress, currency);

    public void AddItem(Sku sku, int quantity, Money unitPrice)
    {
        EnsureDraft();
        if (unitPrice.Currency != Currency)
            throw new DomainException($"This order is priced in {Currency}.");

        var line = _lines.Find(l => l.Sku == sku);
        if (line is not null)
        {
            line.IncreaseQuantity(quantity);
            return;
        }

        if (_lines.Count == MaxDistinctItems)
            throw new DomainException($"An order holds at most {MaxDistinctItems} items.");
        _lines.Add(new OrderLine(sku, quantity, unitPrice));
    }

    public void ApplyDiscount(Money discount)
    {
        EnsureDraft();
        if (discount.Amount > Subtotal.Amount)
            throw new DomainException("A discount cannot exceed the subtotal.");
        Discount = discount;
    }

    public void Place(DateTimeOffset now)
    {
        EnsureDraft();
        if (_lines.Count == 0)
            throw new DomainException("Cannot place an empty order.");

        Status = OrderStatus.Placed;
        Raise(new OrderPlaced(Id, CustomerId, Total, now));
    }

    private void EnsureDraft()
    {
        if (Status != OrderStatus.Draft)
            throw new DomainException($"Order {Id.Value} is {Status}, not Draft.");
    }
}

public sealed class OrderLine
{
    private OrderLine() { } // For EF Core.

    internal OrderLine(Sku sku, int quantity, Money unitPrice)
    {
        Sku = sku;
        UnitPrice = unitPrice;
        IncreaseQuantity(quantity);
    }

    public Sku Sku { get; private set; } = null!;
    public int Quantity { get; private set; }
    public Money UnitPrice { get; private set; } = null!;
    public Money Subtotal => UnitPrice.Multiply(Quantity);

    internal void IncreaseQuantity(int quantity)
    {
        if (quantity <= 0 || Quantity + quantity > 999)
            throw new DomainException("Quantity per item must stay between 1 and 999.");
        Quantity += quantity;
    }
}

public enum OrderStatus { Draft, Placed, Shipped, Cancelled }

public sealed class DomainException(string message) : Exception(message);