Clean Architecture

// Application/Common/Interfaces/IAppDbContext.cspublic interface IAppDbContext{    DbSet<Order> Orders { get; }    DbSet<Product> Products { get; }    Task<int> SaveChangesAsync(CancellationToken ct = default);}
// Infrastructure/Persistence/AppDbContext.cspublic class AppDbContext(DbContextOptions<AppDbContext> options)    : DbContext(options), IAppDbContext{    public DbSet<Order> Orders => Set<Order>();    public DbSet<Product> Products => Set<Product>();
    protected override void OnModelCreating(ModelBuilder modelBuilder)    {        modelBuilder.ApplyConfigurationsFromAssembly(typeof(AppDbContext).Assembly);    }}

// Application/Orders/Commands/CreateOrder/CreateOrderCommand.cspublic record CreateOrderCommand(    string CustomerId,    List<OrderItemDto> Items) : IRequest<Result<Guid>>;
public record OrderItemDto(string ProductId, int Quantity, decimal UnitPrice);
// Application/Orders/Commands/CreateOrder/CreateOrderHandler.cs — uses Mediator (source-generated, MIT)internal sealed class CreateOrderHandler(    IAppDbContext db,    TimeProvider clock) : IRequestHandler<CreateOrderCommand, Result<Guid>>{    public async ValueTask<Result<Guid>> Handle(CreateOrderCommand request, CancellationToken ct)    {        var order = Order.Create(            request.CustomerId,            request.Items.Select(i => new OrderItem(i.ProductId, i.Quantity, i.UnitPrice)),            clock.GetUtcNow());
        db.Orders.Add(order);        await db.SaveChangesAsync(ct);
        return Result.Success(order.Id);    }}
// Application/Orders/Commands/CreateOrder/CreateOrderValidator.cspublic class CreateOrderValidator : AbstractValidator<CreateOrderCommand>{    public CreateOrderValidator()    {        RuleFor(x => x.CustomerId).NotEmpty();        RuleFor(x => x.Items).NotEmpty();        RuleForEach(x => x.Items).ChildRules(item =>        {            item.RuleFor(x => x.ProductId).NotEmpty();            item.RuleFor(x => x.Quantity).GreaterThan(0);            item.RuleFor(x => x.UnitPrice).GreaterThan(0);        });    }}

// Application/Orders/Queries/GetOrder/GetOrderQuery.cspublic record GetOrderQuery(Guid OrderId) : IRequest<Result<OrderDto>>;
public record OrderDto(Guid Id, string CustomerId, decimal Total, string Status, DateTimeOffset CreatedAt);
// Application/Orders/Queries/GetOrder/GetOrderHandler.csinternal sealed class GetOrderHandler(IAppDbContext db) : IRequestHandler<GetOrderQuery, Result<OrderDto>>{    public async ValueTask<Result<OrderDto>> Handle(GetOrderQuery request, CancellationToken ct)    {        var order = await db.Orders            .Where(o => o.Id == request.OrderId)            .Select(o => new OrderDto(o.Id, o.CustomerId, o.Total, o.Status.ToString(), o.CreatedAt))            .FirstOrDefaultAsync(ct);
        return order is not null            ? Result.Success(order)            : Result.Failure<OrderDto>("Order not found");    }}

// Domain/Entities/Order.cspublic class Order : Entity{    private readonly List<OrderItem> _items = [];
    private Order() { } // EF Core
    public string CustomerId { get; private set; } = null!;    public OrderStatus Status { get; private set; }    public decimal Total { get; private set; }    public DateTimeOffset CreatedAt { get; private set; }    public IReadOnlyList<OrderItem> Items => _items.AsReadOnly();
    public static Order Create(string customerId, IEnumerable<OrderItem> items, DateTimeOffset now)    {        var order = new Order        {            Id = Guid.CreateVersion7(),            CustomerId = customerId,            Status = OrderStatus.Pending,            CreatedAt = now        };
        foreach (var item in items)            order.AddItem(item);
        return order;    }
    public void AddItem(OrderItem item)    {        _items.Add(item);        Total = _items.Sum(i => i.Quantity * i.UnitPrice);    }
    public Result Cancel()    {        if (Status is not OrderStatus.Pending)            return Result.Failure("Only pending orders can be cancelled");
        Status = OrderStatus.Cancelled;        return Result.Success();    }}

// Api/Endpoints/OrderEndpoints.cspublic sealed class OrderEndpoints : IEndpointGroup{    public void Map(IEndpointRouteBuilder app)    {        var group = app.MapGroup("/api/orders").WithTags("Orders");
        group.MapPost("/", CreateOrder)            .WithName("CreateOrder");
        group.MapGet("/{id:guid}", GetOrder)            .WithName("GetOrder");
        group.MapGet("/", ListOrders)            .WithName("ListOrders");    }
    private static async Task<IResult> CreateOrder(        CreateOrderCommand command, ISender sender, CancellationToken ct)    {        var result = await sender.Send(command, ct);        return result.IsSuccess            ? TypedResults.Created($"/api/orders/{result.Value}", result.Value)            : result.ToProblemDetails();    }
    private static async Task<IResult> GetOrder(        Guid id, ISender sender, CancellationToken ct)    {        var result = await sender.Send(new GetOrderQuery(id), ct);        return result.IsSuccess            ? TypedResults.Ok(result.Value)            : TypedResults.NotFound();    }
    private static async Task<IResult> ListOrders(        [AsParameters] ListOrdersQuery query, ISender sender, CancellationToken ct)    {        var result = await sender.Send(query, ct);        return TypedResults.Ok(result);    }}

// Infrastructure/DependencyInjection.cspublic static class DependencyInjection{    public static IServiceCollection AddInfrastructure(        this IServiceCollection services,        IConfiguration config)    {        services.AddDbContext<AppDbContext>(options =>            options.UseNpgsql(config.GetConnectionString("DefaultConnection")));
        services.AddScoped<IAppDbContext>(sp => sp.GetRequiredService<AppDbContext>());
        return services;    }}

// BAD — entity is just a data bag, all logic in handlerpublic class Order{    public Guid Id { get; set; }    public string CustomerId { get; set; } = null!;    public decimal Total { get; set; }    public List<OrderItem> Items { get; set; } = [];}
// Handler sets everything directlyorder.Total = order.Items.Sum(i => i.Quantity * i.UnitPrice);order.Status = OrderStatus.Pending;
// GOOD — entity encapsulates its own rules (see Domain Entity pattern above)var order = Order.Create(customerId, items, clock.GetUtcNow());

// BAD — Domain references EF Core// Domain/Services/OrderService.cspublic class OrderService(AppDbContext db) { } // Domain depends on Infrastructure!
// GOOD — Domain defines interfaces, Infrastructure implements// Domain/Interfaces/IOrderRepository.cs (only if you need query abstraction beyond DbSet)// Application/Common/Interfaces/IAppDbContext.cs (preferred)

// BAD — business logic in the endpointapp.MapPost("/orders", async (CreateOrderRequest req, AppDbContext db) =>{    var order = new Order { CustomerId = req.CustomerId };    foreach (var item in req.Items)    {        order.Items.Add(new OrderItem { ProductId = item.ProductId, Quantity = item.Quantity });    }    order.Total = order.Items.Sum(i => i.Quantity * i.UnitPrice);    db.Orders.Add(order);    await db.SaveChangesAsync();    return TypedResults.Created($"/orders/{order.Id}", order);});
// GOOD — endpoint delegates to a use caseapp.MapPost("/orders", async (CreateOrderCommand command, ISender sender, CancellationToken ct) =>{    var result = await sender.Send(command, ct);    return result.IsSuccess        ? TypedResults.Created($"/orders/{result.Value}", result.Value)        : result.ToProblemDetails();});

// BAD — repository per entity duplicates DbSet functionalitypublic interface IOrderRepository { Task<Order?> GetByIdAsync(Guid id); }public interface IProductRepository { Task<Product?> GetByIdAsync(Guid id); }public interface ICustomerRepository { Task<Customer?> GetByIdAsync(Guid id); }
// GOOD — use IAppDbContext with DbSet<T> directly// Only create a repository interface when you have complex query logic// that you want to test in isolation or reuse across multiple use cases