Clean Architecture and Domain-Driven Design in Practice 2025

// C# - Application Command Handler (CQRS)
public class CreateOrderCommandHandler
    : ICommandHandler<CreateOrderCommand, OrderDto>
{
    private readonly IOrderRepository _orders;
    private readonly IProductRepository _products;
    private readonly IUnitOfWork _unitOfWork;

    public async Task<OrderDto> Handle(
        CreateOrderCommand command,
        CancellationToken ct)
    {
        // 1. Load aggregate
        var customer = await _customers.GetByIdAsync(
            command.CustomerId, ct);

        // 2. Create domain entity
        var order = Order.Create(customer.Id);

        // 3. Business logic (delegated to domain)
        foreach (var item in command.Items)
        {
            var product = await _products.GetByIdAsync(
                item.ProductId, ct);
            order.AddItem(product, item.Quantity);
        }

        // 4. Persist
        await _orders.AddAsync(order, ct);
        await _unitOfWork.SaveChangesAsync(ct);

        // 5. Return DTO (not domain entity!)
        return OrderDto.FromDomain(order);
    }
}

// TypeScript - similar pattern
export class CreateOrderHandler
  implements ICommandHandler<CreateOrderCommand>
{
  constructor(
    private orders: IOrderRepository,
    private products: IProductRepository,
    private unitOfWork: IUnitOfWork
  ) {}

  async execute(command: CreateOrderCommand): Promise<OrderDto> {
    const order = Order.create(command.customerId);

    for (const item of command.items) {
      const product = await this.products.getById(item.productId);
      order.addItem(product, item.quantity);
    }

    await this.orders.save(order);
    await this.unitOfWork.commit();

    return OrderDto.fromDomain(order);
  }
}

// C# - Infrastructure Repository Implementation
public class EfOrderRepository : IOrderRepository  // implements domain interface
{
    private readonly AppDbContext _context;

    public async Task<Order?> GetByIdAsync(OrderId id, CancellationToken ct)
    {
        return await _context.Orders
            .Include(o => o.Items)  // EF navigation
            .FirstOrDefaultAsync(o => o.Id == id, ct);
    }

    public async Task AddAsync(Order order, CancellationToken ct)
    {
        await _context.Orders.AddAsync(order, ct);
    }
}

// EF Core configuration (infrastructure concern)
public class OrderConfiguration : IEntityTypeConfiguration<Order>
{
    public void Configure(EntityTypeBuilder<Order> builder)
    {
        builder.ToTable("Orders");
        builder.HasKey(o => o.Id);

        builder.Property(o => o.Id)
            .HasConversion(id => id.Value, value => new OrderId(value));

        builder.OwnsMany(o => o.Items, items =>
        {
            items.ToTable("OrderItems");
            items.WithOwner().HasForeignKey("OrderId");
            items.Property(i => i.UnitPrice)
                .HasConversion(
                    money => money.Amount,
                    amount => new Money(amount));
        });
    }
}

// ASP.NET Core - API Controller (thin!)
[ApiController]
[Route("api/orders")]
public class OrdersController : ControllerBase
{
    private readonly IMediator _mediator;  // MediatR for CQRS

    [HttpPost]
    public async Task<ActionResult<OrderDto>> CreateOrder(
        [FromBody] CreateOrderRequest request,
        CancellationToken ct)
    {
        // Validation via FluentValidation (middleware)
        var command = new CreateOrderCommand(
            request.CustomerId,
            request.Items);

        // Delegate to application layer
        var result = await _mediator.Send(command, ct);

        return CreatedAtAction(
            nameof(GetOrder),
            new { id = result.Id },
            result);
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<OrderDto>> GetOrder(
        Guid id,
        CancellationToken ct)
    {
        var query = new GetOrderQuery(id);
        var result = await _mediator.Send(query, ct);

        return result is null ? NotFound() : Ok(result);
    }
}