ASP.NET Core Minimal APIs elimineren de ceremonie van traditionele MVC-controllers en bieden een gestroomlijnde aanpak voor het bouwen van HTTP-endpoints met aanzienlijk minder boilerplate-code. Geïntroduceerd in .NET 6 en verfijnd door .NET 8, 9 en nu .NET 10, zijn Minimal APIs uitgegroeid tot een productierijpe keuze voor microservices, serverless functies en lichtgewicht webservices.

Minimal APIs vs Controllers

Minimal APIs gebruiken top-level route handlers die direct in Program.cs worden gedefinieerd, terwijl MVC-controllers klassedefinities, attributen en conventie-gebaseerde routing vereisen. Voor eenvoudige CRUD-operaties of microservices met minder dan 20 endpoints, reduceren Minimal APIs de code typisch met 40-60%.

Minimal API Architectuur en Request Pipeline

De ASP.NET Core request pipeline verwerkt HTTP-verzoeken via middleware-componenten voordat ze de endpoint handlers bereiken. Minimal APIs integreren naadloos met deze pipeline terwijl ze een meer declaratieve syntax bieden voor routedefinitie.

Program.cscsharp

var builder = WebApplication.CreateBuilder(args);

// Services registreren voor dependency injection
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddScoped<IProductRepository, ProductRepository>();

var app = builder.Build();

// Middleware pipeline configuratie
app.UseExceptionHandler("/error");
app.UseHttpsRedirection();
app.UseAuthorization();

// Minimal API endpoint definities
app.MapGet("/products", async (IProductRepository repo) =>
    Results.Ok(await repo.GetAllAsync()));

app.MapGet("/products/{id:int}", async (int id, IProductRepository repo) =>
    await repo.GetByIdAsync(id) is Product product
        ? Results.Ok(product)
        : Results.NotFound());

app.Run();

Dit patroon centraliseert routedefinities terwijl volledige toegang tot de dependency injection container behouden blijft. De IProductRepository parameter demonstreert constructorloze injectie direct in handler delegates.

Route Groups en Endpoint Organisatie

Naarmate applicaties groeien, wordt het organiseren van endpoints cruciaal. Route groups, geïntroduceerd in .NET 7, bieden namespacing en gedeelde configuratie zonder de minimale aanpak op te offeren.

ProductEndpoints.cscsharp

public static class ProductEndpoints
{
    public static void MapProductEndpoints(this WebApplication app)
    {
        var group = app.MapGroup("/api/products")
            .WithTags("Products")
            .RequireAuthorization();

        group.MapGet("/", GetAllProducts);
        group.MapGet("/{id:int}", GetProductById);
        group.MapPost("/", CreateProduct)
            .Accepts<CreateProductRequest>("application/json")
            .Produces<Product>(StatusCodes.Status201Created);
        group.MapPut("/{id:int}", UpdateProduct);
        group.MapDelete("/{id:int}", DeleteProduct)
            .RequireAuthorization("AdminOnly");
    }

    private static async Task<IResult> GetAllProducts(
        IProductRepository repo,
        CancellationToken ct)
    {
        var products = await repo.GetAllAsync(ct);
        return Results.Ok(products);
    }

    private static async Task<IResult> GetProductById(
        int id,
        IProductRepository repo,
        CancellationToken ct)
    {
        var product = await repo.GetByIdAsync(id, ct);
        return product is not null
            ? Results.Ok(product)
            : Results.NotFound();
    }

    private static async Task<IResult> CreateProduct(
        CreateProductRequest request,
        IProductRepository repo,
        IValidator<CreateProductRequest> validator,
        CancellationToken ct)
    {
        var validation = await validator.ValidateAsync(request, ct);
        if (!validation.IsValid)
            return Results.ValidationProblem(validation.ToDictionary());

        var product = await repo.CreateAsync(request.ToProduct(), ct);
        return Results.Created($"/api/products/{product.Id}", product);
    }
}

Door app.MapProductEndpoints() aan te roepen in Program.cs worden alle productroutes geregistreerd met gedeelde autorisatievereisten en OpenAPI-metadata. Deze structuur schaalt goed voor applicaties met honderden endpoints.

Parameter Binding en Validatie

Minimal APIs ondersteunen meerdere binding bronnen: routeparameters, query strings, headers, request bodies en services uit de DI-container. Het begrijpen van de binding prioriteit voorkomt veelvoorkomende valkuilen bij technische sollicitatiegesprekken.

Program.cs - Parameter binding voorbeeldencsharp

app.MapGet("/search", (
    [FromQuery] string? query,           // Expliciete query string
    [FromQuery] int page = 1,            // Standaardwaarde
    [FromQuery] int pageSize = 20,       // Standaardwaarde
    [FromHeader(Name = "X-Correlation-Id")] string? correlationId,
    ILogger<Program> logger) =>
{
    logger.LogInformation("Zoekverzoek: {Query}, Pagina: {Page}, CorrelationId: {CorrelationId}",
        query, page, correlationId);

    return Results.Ok(new { query, page, pageSize, correlationId });
});

// Complex model binding met validatie
app.MapPost("/orders", async (
    [FromBody] CreateOrderRequest request,
    [FromServices] IValidator<CreateOrderRequest> validator,
    [FromServices] IOrderService orderService,
    HttpContext context,
    CancellationToken ct) =>
{
    var validationResult = await validator.ValidateAsync(request, ct);

    if (!validationResult.IsValid)
    {
        return Results.ValidationProblem(
            validationResult.Errors
                .GroupBy(e => e.PropertyName)
                .ToDictionary(
                    g => g.Key,
                    g => g.Select(e => e.ErrorMessage).ToArray()));
    }

    var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
    var order = await orderService.CreateOrderAsync(request, userId!, ct);

    return Results.Created($"/orders/{order.Id}", order);
});

Het [FromBody] attribuut is optioneel voor complexe types maar verbetert de leesbaarheid. FluentValidation integreert natuurlijk via dependency injection, waardoor validatielogica gescheiden blijft van endpoint handlers.

Binding Bron Prioriteit

Wanneer geen attribuut is gespecificeerd, leiden Minimal APIs binding bronnen af: eerst routeparameters, dan query strings voor eenvoudige types, en request body voor complexe types. Expliciete attributen zoals [FromQuery] of [FromBody] overschrijven dit gedrag.

Prestatie-optimalisatie met Native AOT

.NET 8 introduceerde Native AOT (Ahead-of-Time) compilatie-ondersteuning voor Minimal APIs, waardoor zelfstandige uitvoerbare bestanden worden geproduceerd met opstarttijden van minder dan een milliseconde. Deze mogelijkheid maakt Minimal APIs ideaal voor serverless deployments waar cold start latentie belangrijk is.

Program.cs - AOT-compatibele configuratiecsharp

var builder = WebApplication.CreateSlimBuilder(args);

// AOT-vriendelijke JSON serialisatie
builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonContext.Default);
});

var app = builder.Build();

app.MapGet("/health", () => Results.Ok(new HealthResponse("Healthy", DateTime.UtcNow)));

app.Run();

// Broncode-gegenereerde JSON serializer context
[JsonSerializable(typeof(HealthResponse))]
[JsonSerializable(typeof(Product))]
[JsonSerializable(typeof(List<Product>))]
internal partial class AppJsonContext : JsonSerializerContext { }

public record HealthResponse(string Status, DateTime CheckedAt);

De CreateSlimBuilder methode sluit onnodige framework-functies uit, terwijl de broncode-gegenereerde JsonSerializerContext runtime reflection voor JSON serialisatie elimineert. Gepubliceerde AOT-binaries voor eenvoudige APIs meten typisch 10-15 MB vergeleken met 80+ MB voor standaard self-contained deployments.

Typed Results en Response Metadata

.NET 7 introduceerde TypedResults voor compile-time verificatie van response types, wat de nauwkeurigheid van OpenAPI-documentatie verbetert en type-mismatches tijdens ontwikkeling detecteert.

csharp

// Sterk getypeerde results met OpenAPI metadata
app.MapGet("/products/{id:int}", async Task<Results<Ok<Product>, NotFound, ProblemHttpResult>> (
    int id,
    IProductRepository repo,
    CancellationToken ct) =>
{
    try
    {
        var product = await repo.GetByIdAsync(id, ct);

        return product is not null
            ? TypedResults.Ok(product)
            : TypedResults.NotFound();
    }
    catch (Exception ex)
    {
        return TypedResults.Problem(
            detail: "Er is een fout opgetreden bij het ophalen van het product",
            statusCode: StatusCodes.Status500InternalServerError);
    }
})
.WithName("GetProductById")
.WithOpenApi(operation =>
{
    operation.Summary = "Haalt een product op basis van ID";
    operation.Description = "Retourneert de productdetails of 404 indien niet gevonden";
    return operation;
});

Het union type Results<T1, T2, T3> declareert alle mogelijke response types, die Swagger/OpenAPI-generatoren gebruiken om nauwkeurige documentatie te produceren. Dit patroon is bijzonder waardevol bij voorbereiding op ASP.NET Core sollicitatievragen over API-ontwerp.

Klaar om je .NET gesprekken te halen?

Oefen met onze interactieve simulatoren, flashcards en technische tests.

Ontdek .NET

Endpoint Filters voor Cross-Cutting Concerns

Endpoint filters bieden middleware-achtige functionaliteit met scope op specifieke endpoints of groepen, en behandelen concerns zoals logging, caching en request transformatie.

ValidationFilter.cscsharp

public class ValidationFilter<T> : IEndpointFilter where T : class
{
    public async ValueTask<object?> InvokeAsync(
        EndpointFilterInvocationContext context,
        EndpointFilterDelegate next)
    {
        var validator = context.HttpContext
            .RequestServices
            .GetService<IValidator<T>>();

        if (validator is null)
            return await next(context);

        var argument = context.Arguments
            .OfType<T>()
            .FirstOrDefault();

        if (argument is null)
            return await next(context);

        var validationResult = await validator.ValidateAsync(argument);

        if (!validationResult.IsValid)
        {
            return Results.ValidationProblem(
                validationResult.Errors
                    .GroupBy(e => e.PropertyName)
                    .ToDictionary(
                        g => g.Key,
                        g => g.Select(e => e.ErrorMessage).ToArray()));
        }

        return await next(context);
    }
}

// Gebruik in Program.cs
app.MapPost("/products", CreateProduct)
    .AddEndpointFilter<ValidationFilter<CreateProductRequest>>();

// Globale filter registratie via route group
var api = app.MapGroup("/api")
    .AddEndpointFilter(async (context, next) =>
    {
        var logger = context.HttpContext
            .RequestServices
            .GetRequiredService<ILogger<Program>>();

        var stopwatch = Stopwatch.StartNew();
        var result = await next(context);
        stopwatch.Stop();

        logger.LogInformation(
            "Endpoint {Method} {Path} voltooid in {ElapsedMs}ms",
            context.HttpContext.Request.Method,
            context.HttpContext.Request.Path,
            stopwatch.ElapsedMilliseconds);

        return result;
    });

Filters worden uitgevoerd in volgorde van registratie, waarbij de binnenste filter het dichtst bij de endpoint handler staat. Deze architectuur maakt een schone scheiding van validatie-, logging- en autorisatielogica mogelijk.

Authenticatie- en Autorisatiepatronen

Minimal APIs ondersteunen dezelfde authenticatie- en autorisatiemechanismen als MVC-controllers, met een meer declaratieve configuratiesyntax.

Program.cs - JWT authenticatie setupcsharp

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!))
        };
    });

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("AdminOnly", policy =>
        policy.RequireRole("Admin"))
    .AddPolicy("PremiumUser", policy =>
        policy.RequireClaim("subscription", "premium", "enterprise"));

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

// Beveiligde endpoints
app.MapGet("/admin/users", async (IUserService userService) =>
    Results.Ok(await userService.GetAllUsersAsync()))
    .RequireAuthorization("AdminOnly");

app.MapGet("/profile", async (ClaimsPrincipal user, IUserService userService) =>
{
    var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
    var profile = await userService.GetProfileAsync(userId!);
    return Results.Ok(profile);
})
.RequireAuthorization();

// Anoniem endpoint binnen beveiligde groep
var protectedGroup = app.MapGroup("/api/secure")
    .RequireAuthorization();

protectedGroup.MapGet("/public-info", () => Results.Ok("Dit is publiek"))
    .AllowAnonymous();

De RequireAuthorization extensiemethode accepteert policy-namen of kan zonder argumenten worden aangeroepen om elke geauthenticeerde gebruiker te vereisen. Het begrijpen van deze patronen is essentieel voor authenticatie en autorisatie sollicitatievragen.

Sollicitatievragen: Veelvoorkomende Patronen

Technische sollicitatiegesprekken verkennen vaak de verschillen tussen Minimal APIs en traditionele controllers. De onderstaande tabel vat de belangrijkste verschillen samen:

| Aspect | Minimal APIs | MVC Controllers | |--------|--------------|----------------| | Boilerplate | Laag - directe handler delegates | Hoger - klasse + methode + attributen | | Routing | Inline met MapGet, MapPost | Attribuut- of conventie-gebaseerd | | Model Binding | Automatisch met optionele attributen | Conventie + attributen | | Filters | Endpoint filters | Action filters + middleware | | AOT Ondersteuning | Volledige ondersteuning sinds .NET 8 | Beperkt, reflection-zwaar | | Testbaarheid | Functie-gebaseerd, eenvoudig te testen | Vereist controller instantiatie | | Beste voor | Microservices, eenvoudige APIs | Grote applicaties, complexe workflows |

Sollicitatietip

Wanneer gevraagd wordt "Wanneer zou je controllers kiezen boven Minimal APIs?", noem complexe applicaties die action filters, model binding aanpassingen, of bestaande codebases met gevestigde MVC-patronen vereisen. Minimal APIs excelleren voor greenfield microservices en serverless functies.

Testen van Minimal API Endpoints

Integratietesten met WebApplicationFactory bieden realistische endpoint verificatie zonder de applicatie te deployen.

ProductEndpointsTests.cscsharp

public class ProductEndpointsTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;
    private readonly WebApplicationFactory<Program> _factory;

    public ProductEndpointsTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // Echte repository vervangen door mock
                services.RemoveAll<IProductRepository>();
                services.AddScoped<IProductRepository, MockProductRepository>();
            });
        });
        _client = _factory.CreateClient();
    }

    [Fact]
    public async Task GetProducts_ReturnsOkWithProductList()
    {
        // Act
        var response = await _client.GetAsync("/api/products");

        // Assert
        response.StatusCode.Should().Be(HttpStatusCode.OK);

        var products = await response.Content
            .ReadFromJsonAsync<List<Product>>();

        products.Should().NotBeNull();
        products.Should().HaveCountGreaterThan(0);
    }

    [Fact]
    public async Task GetProductById_WithInvalidId_ReturnsNotFound()
    {
        // Act
        var response = await _client.GetAsync("/api/products/99999");

        // Assert
        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
    }

    [Fact]
    public async Task CreateProduct_WithValidRequest_ReturnsCreated()
    {
        // Arrange
        var request = new CreateProductRequest("Test Product", 29.99m, "Test Beschrijving");

        // Act
        var response = await _client.PostAsJsonAsync("/api/products", request);

        // Assert
        response.StatusCode.Should().Be(HttpStatusCode.Created);
        response.Headers.Location.Should().NotBeNull();
    }
}

Voor een diepere verkenning van Clean Architecture patronen in .NET-applicaties, moet de servicelaag onafhankelijk worden getest met unit tests, terwijl integratietests de volledige request pipeline verifiëren.

Conclusie

Minimal APIs vertegenwoordigen de moderne aanpak voor het bouwen van HTTP-services in ASP.NET Core:

Route groups en endpoint organisatie schalen van eenvoudige microservices tot complexe applicaties
Endpoint filters bieden schone scheiding van cross-cutting concerns zoals validatie en logging
TypedResults maken compile-time verificatie van response types en nauwkeurige OpenAPI-documentatie mogelijk
Native AOT-compilatie levert opstarttijden van minder dan een milliseconde voor serverless deployments
Integratietesten met WebApplicationFactory garanderen realistische endpoint verificatie

Voor sollicitatievoorbereiding, focus op het articuleren wanneer Minimal APIs geschikt zijn versus traditionele controllers, en demonstreer begrip van de request pipeline, dependency injection en authenticatiepatronen.

Begin met oefenen!

Test je kennis met onze gespreksimulatoren en technische tests.

Maak mijn gratis account aan

ASP.NET Core Minimal APIs in 2026: Architectuur, Prestaties en Sollicitatievragen