Vertical Slice

// Features/Orders/CreateOrder.cs
public static class CreateOrder{    public record Command(string CustomerId, List<OrderItemDto> Items) : IRequest<Result<OrderResponse>>;
    public record OrderItemDto(string ProductId, int Quantity);
    public record OrderResponse(Guid Id, decimal Total, DateTime CreatedAt);
    public class Validator : AbstractValidator<Command>    {        public Validator()        {            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);            });        }    }
    internal sealed class Handler(AppDbContext db, TimeProvider clock) : IRequestHandler<Command, Result<OrderResponse>>    {        public async ValueTask<Result<OrderResponse>> Handle(Command request, CancellationToken ct)        {            var order = Order.Create(request.CustomerId, request.Items, clock.GetUtcNow());            db.Orders.Add(order);            await db.SaveChangesAsync(ct);
            return Result.Success(new OrderResponse(order.Id, order.Total, order.CreatedAt));        }    }}
// Registration in Program.cs or module DIbuilder.Services.AddMediator();
// Features/Orders/OrderEndpoints.cs — auto-discovered via IEndpointGrouppublic sealed class OrderEndpoints : IEndpointGroup{    public void Map(IEndpointRouteBuilder app)    {        var group = app.MapGroup("/api/orders").WithTags("Orders");
        group.MapPost("/", async (CreateOrder.Command command, ISender sender, CancellationToken ct) =>        {            var result = await sender.Send(command, ct);            return result.IsSuccess                ? TypedResults.Created($"/api/orders/{result.Value.Id}", result.Value)                : result.ToProblemDetails();        })        .WithName("CreateOrder").Produces<CreateOrder.OrderResponse>(201)        .ProducesValidationProblem()        .AddEndpointFilter<ValidationFilter<CreateOrder.Command>>();    }}

// Features/Orders/CreateOrder.cs
public static class CreateOrder{    public record Command(string CustomerId, List<OrderItemDto> Items);
    public record OrderItemDto(string ProductId, int Quantity);
    public record OrderResponse(Guid Id, decimal Total, DateTime CreatedAt);
    // Wolverine discovers this by convention (static Handle method)    public static async Task<Result<OrderResponse>> Handle(        Command command,        AppDbContext db,        TimeProvider clock,        CancellationToken ct)    {        var order = Order.Create(command.CustomerId, command.Items, clock.GetUtcNow());        db.Orders.Add(order);        await db.SaveChangesAsync(ct);        return Result.Success(new OrderResponse(order.Id, order.Total, order.CreatedAt));    }}

// Features/Orders/CreateOrder.cs
public static class CreateOrder{    public record Command(string CustomerId, List<OrderItemDto> Items);
    public record OrderItemDto(string ProductId, int Quantity);
    public record OrderResponse(Guid Id, decimal Total, DateTime CreatedAt);
    internal class Handler(AppDbContext db, TimeProvider clock)    {        public async Task<Result<OrderResponse>> ExecuteAsync(Command command, CancellationToken ct)        {            var order = Order.Create(command.CustomerId, command.Items, clock.GetUtcNow());            db.Orders.Add(order);            await db.SaveChangesAsync(ct);
            return Result.Success(new OrderResponse(order.Id, order.Total, order.CreatedAt));        }    }}
// Endpoint wiring — Result maps to HTTP responsegroup.MapPost("/", async (CreateOrder.Command command, CreateOrder.Handler handler, CancellationToken ct) =>{    var result = await handler.ExecuteAsync(command, ct);    return result.IsSuccess        ? TypedResults.Created($"/api/orders/{result.Value.Id}", result.Value)        : result.ToProblemDetails();});

// Common/Behaviors/ValidationBehavior.cs (Mediator pipeline)public sealed class ValidationBehavior<TRequest, TResponse>(IEnumerable<IValidator<TRequest>> validators)    : IPipelineBehavior<TRequest, TResponse>    where TRequest : IMessage{    public async ValueTask<TResponse> Handle(        TRequest request,        MessageHandlerDelegate<TRequest, TResponse> next,        CancellationToken ct)    {        var context = new ValidationContext<TRequest>(request);        var failures = validators            .Select(v => v.Validate(context))            .SelectMany(r => r.Errors)            .Where(f => f is not null)            .ToList();
        if (failures.Count > 0)            throw new ValidationException(failures);
        return await next(request, ct);    }}

// BAD — a feature folder with its own service layer and repositoryFeatures/  Orders/    CreateOrder.cs    IOrderService.cs         # unnecessary abstraction    OrderService.cs          # unnecessary abstraction    IOrderRepository.cs      # unnecessary abstraction    OrderRepository.cs       # unnecessary abstraction
// GOOD — handler talks directly to DbContextFeatures/  Orders/    CreateOrder.cs           # handler uses AppDbContext directly

// BAD — CreateOrder directly calls GetProduct handlervar product = await _getProductHandler.Handle(new GetProduct.Query(productId));
// GOOD — query the database directly or use a shared read modelvar product = await db.Products.FindAsync(productId, ct);

// BAD — 500-line file with CRUD + business logic + mappingpublic static class Orders{    // Create, Read, Update, Delete, Cancel, Refund, Export...}
// GOOD — one file per operationFeatures/Orders/CreateOrder.csFeatures/Orders/GetOrder.csFeatures/Orders/CancelOrder.cs