Mapping Endpoints

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Uptime monitors and some CDNs send HEAD; MapGet alone would answer 405.
app.MapMethods("/products/{sku}/image", [HttpMethods.Get, HttpMethods.Head], (string sku, HttpContext context) =>
{
    var path = Path.Combine("catalog-images", Path.GetFileName(sku) + ".webp");
    if (!File.Exists(path)) return Results.NotFound();

    // For HEAD the server sends the headers and Content-Length but no body.
    return Results.File(Path.GetFullPath(path), "image/webp", enableRangeProcessing: true);
});

// One handler for several verbs is rare; prefer separate MapPut/MapPatch when the semantics differ.
app.MapMethods("/inventory/{sku}/reservation", [HttpMethods.Put, HttpMethods.Delete], (string sku, HttpRequest request) =>
    request.Method == HttpMethods.Put
        ? Results.Ok(new { sku, reserved = true })
        : Results.NoContent());

app.Run();

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpClient<PaymentGateway>(client => client.BaseAddress = new Uri("https://payments.example.com"));
builder.Services.AddSingleton<PaymentLedger>();
var app = builder.Build();

app.MapPost("/orders/{id:int}/payments", async (int id, PaymentRequest request, PaymentGateway gateway, PaymentLedger ledger, CancellationToken ct) =>
{
    // Before the first side effect: if the client has gone, do not start the capture.
    ct.ThrowIfCancellationRequested();

    // From here on the request token is ignored: a disconnect mid-capture must not abandon
    // a capture the provider may already have performed. The client's own timeout still applies.
    var capture = await gateway.CaptureAsync(id, request.Amount, CancellationToken.None);

    // Not cancellable: the money has moved, so the record must be written even if the client disconnected.
    await ledger.RecordAsync(id, capture.ProviderReference, request.Amount, CancellationToken.None);

    return Results.Ok(capture);
});

app.Run();

record PaymentRequest(decimal Amount);
record CaptureResult(string ProviderReference, string Status);

class PaymentGateway(HttpClient http)
{
    public async Task<CaptureResult> CaptureAsync(int orderId, decimal amount, CancellationToken ct)
    {
        using var message = new HttpRequestMessage(HttpMethod.Post, "/captures")
        {
            Content = JsonContent.Create(new { orderId, amount })
        };
        // Same key on every retry for this order, so the provider captures at most once.
        message.Headers.Add("Idempotency-Key", $"order-{orderId}-capture");
        using var response = await http.SendAsync(message, ct);
        response.EnsureSuccessStatusCode();
        return (await response.Content.ReadFromJsonAsync<CaptureResult>(ct))!;
    }
}

class PaymentLedger
{
    public Task RecordAsync(int orderId, string reference, decimal amount, CancellationToken ct) => Task.CompletedTask;
}

using System.Collections.Concurrent;
using Microsoft.AspNetCore.Http.HttpResults;
using Xunit;

public class OrderHandlerTests
{
    [Fact]
    public async Task GetById_returns_404_for_an_unknown_order()
    {
        var store = new OrderStore();

        var result = await OrderHandlers.GetById(999, store, TestContext.Current.CancellationToken);

        Assert.IsType<NotFound>(result);
    }

    [Fact]
    public async Task GetById_returns_the_order()
    {
        var store = new OrderStore();
        store.Add(new Order(7, "C-1001", 129.90m));

        var result = await OrderHandlers.GetById(7, store, TestContext.Current.CancellationToken);

        var ok = Assert.IsType<Ok<Order>>(result);
        Assert.Equal(129.90m, ok.Value!.Total);
    }
}

public static class OrderHandlers
{
    public static async Task<IResult> GetById(int id, OrderStore store, CancellationToken ct)
    {
        var order = await store.FindAsync(id, ct);
        return order is null ? TypedResults.NotFound() : TypedResults.Ok(order);
    }
}

public sealed class OrderStore
{
    private readonly ConcurrentDictionary<int, Order> _orders = new();
    public void Add(Order order) => _orders[order.Id] = order;
    public Task<Order?> FindAsync(int id, CancellationToken ct) => Task.FromResult(_orders.GetValueOrDefault(id));
}

public record Order(int Id, string CustomerId, decimal Total);