Demarbit.Results.AspNetCore 1.0.0

Demarbit.Results

A lightweight Result pattern library for .NET 10. Replace exceptions as control flow with explicit Result<TValue> and Result<TValue, TError> types — designed for CQRS pipelines and Clean Architecture.

Getting Started

dotnet add package Demarbit.Results

For ASP.NET Core integration (ProblemDetails mapping, minimal API support):

dotnet add package Demarbit.Results.AspNetCore

Return Results from handlers

using Demarbit.Results;

// Implicit conversions make this ergonomic
public Result<Order> Handle(CreateOrderCommand command)
{
    if (string.IsNullOrEmpty(command.Name))
        return new ValidationError("Name", "Name is required");

    var order = Order.Create(command.Name);
    return order; // implicitly wraps in Result<Order>
}

Pattern match on results

var result = handler.Handle(command);

var response = result.Match(
    onSuccess: order => $"Created order {order.Id}",
    onFailure: error => $"Failed: {error.Message}");

Chain operations with combinators

var output = await GetOrderAsync(id)
    .Map(order => order.ToDto())
    .TapAsync(dto => LogAccessAsync(dto.Id))
    .Match(
        onSuccess: dto => Results.Ok(dto),
        onFailure: error => Results.Problem(error.ToProblemDetails()));

Validate with multiple errors

return Result.Validate(
    order,
    Error.When(string.IsNullOrEmpty(order.Name), "Name", "Name is required"),
    Error.When(order.Quantity <= 0, "Quantity", "Must be positive"),
    Error.When(order.Total < 0, "Total", "Cannot be negative"));

Map to HTTP responses (ASP.NET Core)

using Demarbit.Results.AspNetCore;

// In a minimal API endpoint
app.MapPost("/orders", (CreateOrderCommand cmd, IOrderService svc) =>
    svc.CreateOrder(cmd).ToHttpResult());
// Success → 200 OK, ValidationError → 400, NotFoundError → 404, ConflictError → 409

// Or use the endpoint filter for automatic mapping
app.MapGroup("/api")
   .WithResultMapping();

Error Types

Packages

Dual-Generic Results

For domain methods that return specific error types, use Result<TValue, TError> to enable exhaustive switch matching:

public Result<Order, OrderError> PlaceOrder(OrderRequest request)
{
    if (!request.IsValid)
        return new OrderValidationError(request.Errors);

    if (inventory.IsOutOfStock(request.ProductId))
        return new OutOfStockError(request.ProductId);

    return Order.Create(request);
}

// Callers get typed errors for exhaustive matching
var message = result.Match(
    onSuccess: order => "Placed!",
    onFailure: error => error switch
    {
        OrderValidationError ve => $"Invalid: {ve.Message}",
        OutOfStockError oos => $"Out of stock: {oos.ProductId}",
        _ => "Unknown error"
    });

Convert to single-generic when crossing into the application layer:

Result<Order> applicationResult = domainResult.ToResult();

License

MIT — see LICENSE for details.