Minimal API's of controllers

ASP.NET Core heeft twee manieren om een API te schrijven: minimal API's (app.MapGet(...), zoals in les 1) en controllers (klassen met [HttpGet]-attributen). Ze draaien op dezelfde basis en kunnen naast elkaar bestaan. In deze les schrijf je hetzelfde endpoint op beide manieren, en kies je een structuur voor de rest van de cursus.

Minimal API's, netjes georganiseerd

Program.cs met tachtig MapGet-regels is onleesbaar. Zet endpoints per resource in een eigen bestand:

// Endpoints/ProductEndpoints.cs
public static class ProductEndpoints
{
    public static RouteGroupBuilder MapProducten(this IEndpointRouteBuilder app)
    {
        var groep = app.MapGroup("/v1/producten").WithTags("Producten");
        groep.MapGet("/", Lijst);
        groep.MapGet("/{id:int}", EenProduct).WithName("ProductOphalen");
        groep.MapPost("/", Maak);
        return groep;
    }

    static Ok<List<Product>> Lijst(ProductOpslag opslag) => TypedResults.Ok(opslag.Alle());

    static Results<Ok<Product>, NotFound> EenProduct(int id, ProductOpslag opslag) =>
        opslag.Zoek(id) is { } p ? TypedResults.Ok(p) : TypedResults.NotFound();

    static CreatedAtRoute<Product> Maak(Product nieuw, ProductOpslag opslag)
    {
        opslag.Voeg(nieuw);
        return TypedResults.CreatedAtRoute(nieuw, "ProductOphalen", new { id = nieuw.Id });
    }
}

// Program.cs
builder.Services.AddSingleton<ProductOpslag>();
var app = builder.Build();
app.MapProducten();
app.Run();

• TypedResults in plaats van Results: het returntype (Results<Ok<Product>, NotFound>) zegt precies welke antwoorden mogelijk zijn. OpenAPI (les 6) en unit-tests lezen dat.
• MapGroup deelt het voorvoegsel, tags en later ook autorisatie en filters.
• ProductOpslag is een eenvoudige klasse die de lijst beheert; de container (les 7) geeft hem aan elke handler.

Hetzelfde als controller

[ApiController]
[Route("v1/producten")]
public class ProductenController(ProductOpslag opslag) : ControllerBase
{
    [HttpGet]
    public ActionResult<List<Product>> Lijst() => opslag.Alle();

    [HttpGet("{id:int}", Name = "ProductOphalenCtrl")]
    public ActionResult<Product> EenProduct(int id) => opslag.Zoek(id) is { } p ? p : NotFound();

    [HttpPost]
    public ActionResult<Product> Maak(Product nieuw)
    {
        opslag.Voeg(nieuw);
        return CreatedAtRoute("ProductOphalenCtrl", new { id = nieuw.Id }, nieuw);
    }
}

builder.Services.AddControllers();
...
app.MapControllers();

[ApiController] zet handige gedragingen aan: automatische 400 bij ongeldige invoer (les 5), body-binding zonder [FromBody], en ProblemDetails bij fouten.

Voorspel eerst: je registreert beide versies tegelijk op /v1/producten. Wat gebeurt er bij GET /v1/producten?

Vergelijking

Beide zijn prima. Deze cursus gebruikt minimal API's in groepen per resource: kort, expliciet en de richting waarin ASP.NET Core zich ontwikkelt. Kom je in een team met controllers, dan herken je alles.

Mappenstructuur

Winkel.Api/
├── Program.cs
├── Endpoints/      ProductEndpoints.cs, BestellingEndpoints.cs
├── Domein/         Product.cs, Bestelling.cs
├── Contracten/     DTO's (les 4)
├── Data/           DbContext (les 8)
└── Diensten/       ProductOpslag.cs, ...

Typische fouten

• AmbiguousMatchException: twee endpoints op dezelfde route en methode.
• Controller wordt niet gevonden: AddControllers() of MapControllers() vergeten, of de klasse is niet public.
• CreatedAtRoute faalt met "No route matches": de naam in WithName/Name = klopt niet.

Oefenen

public class ProductOpslag
{
    private readonly List<Product> _items = [new(1, "Toetsenbord", 39.95m), new(2, "Muis", 19.95m)];
    private readonly object _slot = new();
    public List<Product> Alle() { lock (_slot) return [.. _items]; }
    public Product? Zoek(int id) { lock (_slot) return _items.FirstOrDefault(p => p.Id == id); }
    public void Voeg(Product p) { lock (_slot) _items.Add(p); }
    public bool Verwijder(int id) { lock (_slot) return _items.RemoveAll(p => p.Id == id) > 0; }
}

static Results<NoContent, NotFound> Verwijder(int id, ProductOpslag opslag) =>
    opslag.Verwijder(id) ? TypedResults.NoContent() : TypedResults.NotFound();

[HttpDelete("{id:int}")]
public IActionResult Verwijder(int id) => opslag.Verwijder(id) ? NoContent() : NotFound();

[Fact]
public void Onbekend_product_geeft_NotFound()
{
    var resultaat = ProductEndpoints.EenProduct(99, new ProductOpslag());
    Assert.IsType<NotFound>(resultaat.Result);
}

Lokaal oefenen

Geen live lab. Controleer met je .http-bestand dat alle endpoints nog werken na het verhuizen.

Samenvatting

• Minimal API's en controllers zijn gelijkwaardig; kies per route één stijl.
• MapGroup + extensiemethodes per resource houden Program.cs klein; TypedResults maakt antwoorden expliciet en testbaar.
• Volgende les: DTO's en model binding.