ASP.NET Core e Minimal APIs: Menos Cerimônia, Alto Throughput e Roteamento Otimizado

Durante anos, a construção de APIs REST no ecossistema .NET esteve atrelada à cerimônia pesada do modelo MVC tradicional: a criação de um endpoint simples exigia configurar classes Startup.cs, registrar controladores herdados de ControllerBase, decorar ações com atributos verbosos de rotas e carregar todo o mecanismo de reflexão em tempo de execução do ASP.NET.

A introdução das Minimal APIs transformou a experiência de desenvolvimento web no .NET ao eliminar o excesso de camadas intermediárias. Inspirada pela agilidade e simplicidade de frameworks modernos (como Express no Node.js ou FastAPI no Python), essa abordagem permite declarar rotas, vincular dependências e formatar respostas diretamente em funções e expressões lambdas concisas, reduzindo o consumo de memória e destravando ganhos massivos de vazão (throughput).

A Arquitetura do Roteamento sem Controladores

Em vez de escanear assemblies em busca de classes decoradas para registrar controladores em tempo de execução, as Minimal APIs constroem a árvore de rotas diretamente na inicialização do servidor por meio de métodos de extensão como MapGet e MapPost:

flowchart LR
    subgraph MVC["PIPELINE TRADICIONAL — MVC"]
        direction LR
        MReq["Requisição HTTP"] --> Router["Roteador MVC"] --> Activation["Ativação de Controller<br/>Reflexão e filtros globais"] --> Action["Execução da Action"]
    end

    subgraph Minimal["PIPELINE MODERNO — MINIMAL APIs"]
        direction LR
        NReq["Requisição HTTP"] --> RouteTree["Endpoint Route Tree"] --> Handler["Manipulador direto<br/>AOT, sem reflexão"]
    end

    classDef request fill:#172033,stroke:#38bdf8,color:#f8fafc;
    classDef legacy fill:#2a1f32,stroke:#a855f7,color:#f8fafc;
    classDef modern fill:#0f2724,stroke:#34d399,color:#f8fafc;
    class MReq,NReq request;
    class Router,Activation,Action legacy;
    class RouteTree,Handler modern;

Essa simplificação elimina a alocação desnecessária de instâncias de controladores para cada requisição HTTP recebida, aliviando o trabalho do Garbage Collector em servidores submetidos a cargas extremas de tráfego.

Produtividade com Vinculação Automática de Parâmetros

Apesar da sintaxe minimalista, o mecanismo de injeção e vinculação de parâmetros (Parameter Binding) das Minimal APIs é altamente sofisticado, inferindo automaticamente de onde os dados da requisição devem ser extraídos com base nos tipos declarados no manipulador:

var builder = WebApplication.CreateBuilder(args);

// Registro de dependências no contêiner IoC nativo
builder.Services.AddScoped<IProdutoRepository, ProdutoRepository>();

var app = builder.Build();

// 1. Injeção de dependência e parâmetro de rota
app.MapGet("/api/produtos/{id:guid}", async (Guid id, IProdutoRepository repo) =>
{
    var produto = await repo.ObterPorIdAsync(id);
    return produto is not null ? Results.Ok(produto) : Results.NotFound();
});

// 2. Vinculação automática de payload JSON do corpo da requisição
app.MapPost("/api/produtos", async (NovoProdutoDto dto, IProdutoRepository repo) =>
{
    var idCriado = await repo.CriarAsync(dto);
    return Results.Created($"/api/produtos/{idCriado}", new { Id = idCriado });
});

// 3. Leitura direta de parâmetros de paginação via Query String
app.MapGet("/api/produtos", async (int? pagina, int? limite, IProdutoRepository repo) =>
{
    var resultados = await repo.ListarPaginadoAsync(pagina ?? 1, limite ?? 20);
    return Results.Ok(resultados);
});

app.Run();

O compilador e os geradores de código cuidam da serialização JSON ultra-rápida, validação de tipos de dados e injeção do repositório sem que o desenvolvedor precise escrever anotações redundantes como [FromQuery], [FromRoute] ou [FromBody].

Interceptação e Governança com Endpoint Filters

Para aplicar interesses transversais (como auditoria, telemetria, autenticação ou validação de regras com FluentValidation) sem sujar a lógica do caso de uso, as Minimal APIs utilizam os Endpoint Filters:

// Filtro reutilizável para medir a latência exata da rota
app.MapPost("/api/checkout", async (CheckoutCommand cmd) =>
{
    // Lógica do caso de uso de checkout
    return Results.Ok();
})
.AddEndpointFilter(async (invocationContext, next) =>
{
    var stopwatch = Stopwatch.StartNew();
    
    // Executa o endpoint principal
    var result = await next(invocationContext);
    
    stopwatch.Stop();
    Console.WriteLine($"Rota de checkout executada em {stopwatch.ElapsedMilliseconds} ms");
    return result;
});

Os filtros de endpoint podem ser encadeados e agrupados por prefixo utilizando app.MapGroup("/api/v1/financeiro"), permitindo que um conjunto inteiro de rotas receba políticas de autenticação e validação centralizadas de forma declarativa e limpa.

Compatibilidade com Native AOT e Microsserviços

O maior divisor de águas técnico das Minimal APIs em relação ao MVC antigo é sua compatibilidade nativa com a compilação Native AOT:

• Os controladores tradicionais dependiam fortemente de reflexão dinâmica para localizar ações e instanciar tipos, o que impedia que o compilador eliminasse código morto durante o processo de poda de binários (trimming).
• As Minimal APIs, ao utilizarem geradores de código em tempo de compilação (Request Delegate Generators), mapeiam todas as rotas e tipos de dados estaticamente.

O resultado dessa arquitetura são contêineres Docker compactos, com tempo de inicialização (Cold Start) de menos de 10 milissegundos e consumo inicial de memória de apenas 15 MB de RAM. Essas características consolidam as Minimal APIs como o padrão ideal para o desenvolvimento de microsserviços modernos, funções serverless e ferramentas de borda de alto desempenho no ecossistema .NET.