Programação Por Equipe DevBras

Capa do artigo: N+1 no EF Core: ache antes de microotimizar

N+1 no EF Core: ache antes de microotimizar

Ligue o log SQL do EF Core, conte os DbCommand do request, mate o N+1 com projeção e só então microotimize. Par de ASP.NET mais rápido sem palpite.

A reunião discute se foreach ganha de LINQ e se vale trocar o serializador JSON. Enquanto isso a página de pedidos dispara 201 comandos SQL para 50 linhas e leva quase três segundos. Em aplicação web com banco, o tempo quase sempre está em quantas viagens você faz e quanto dado traz — não no ciclo de CPU do C# na borda.

Este post é o par prático de ASP.NET mais rápido sem palpite: lá o ângulo é medir a request inteira e cortar trabalho à toa; aqui o primeiro corte é achar o N+1 do EF Core com log de SQL, corrigir com projeção e só então falar de microotimização. A figura resume o antes/depois que esperamos no log.

Como o N+1 nasce sem ninguém escrever 201 queries

Você materializa uma lista de entidades e, no loop da view, do mapper ou do DTO, toca numa navegação (pedido.Itens, pedido.Cliente.Nome). Com lazy loading ligado, cada toque vira SELECT. Sem lazy, o mesmo padrão aparece quando alguém chama ToListAsync dentro do foreach. O time “não escreveu 201 queries”; escreveu um loop inocente em cima de um grafo.

A documentação do EF Core cobre o carregamento relacionado em eager loading e o guia de consultas eficientes é direto: projete o necessário, evite trazer entidades inteiras para listagem.

// N+1: 1 query da lista + 1 (ou mais) por linha
var pedidos = await db.Pedidos
    .Where(p => p.ClienteId == clienteId)
    .ToListAsync();

foreach (var p in pedidos)
{
    var itens = await db.Itens
        .Where(i => i.PedidoId == p.Id)
        .ToListAsync();
    // monta DTO...
}

Meça antes de otimizar o LINQ

// Log SQL do EF Core (Development)
builder.Logging.AddFilter(
    "Microsoft.EntityFrameworkCore.Database.Command",
    LogLevel.Information);

// Por request da página lenta, anote:
// - quantas linhas "Executed DbCommand"
// - soma aproximada das durações
// Listagem saudável: em geral 1–3 queries, não 1+N

Reproduza um único GET da página lenta em Development (ou com log amostrado em staging). Conte as linhas Executed DbCommand. Se a contagem cresce linear com o número de linhas da tela, você tem N+1 ou N+M. Guarde o número: é o baseline que o post sem palpite exige antes de qualquer PR de “melhoria”. Sem contador, microbenchmark de serializer é teatro.

Complemente com o tempo total da action (middleware simples ou Application Insights). Às vezes o SQL já está ok e o custo está em serializar um grafo enorme — aí o remédio muda, mas você só sabe depois de separar as fatias.

Include consciente versus projeção

// Melhora viagens, ainda traz colunas a mais
var pedidos = await db.Pedidos
    .AsNoTracking()
    .Include(p => p.Itens)
    .Where(p => p.ClienteId == clienteId)
    .ToListAsync();

Include/ThenInclude reduz viagens, porém carrega colunas e coleções que a listagem não mostra. Em tela de 50 pedidos com 20 itens cada, você pode ter matado o N+1 e ainda assim transferido megabytes à toa. Para listagem, projeção com Select para DTO costuma vencer: uma query, colunas certas, AsNoTracking quando não há update no mesmo request.

// Projeção: uma ida, só o que a tela mostra
var pedidos = await db.Pedidos
    .AsNoTracking()
    .Where(p => p.ClienteId == clienteId)
    .Select(p => new PedidoListaDto(
        p.Id,
        p.CriadoEm,
        p.TotalCentavos,
        p.Itens.Count(),
        p.Itens.Sum(i => i.Quantidade)))
    .ToListAsync();

Confirme no log: poucas queries, tempo caindo de segundos para dezenas ou centenas de milissegundos. Se ainda estiver pesado, aí sim entre no terreno do post irmão: payload JSON, alocações, cache de leitura, índice faltando — sempre com número na mão. Contrato da API estável enquanto a query muda por baixo é o tipo de disciplina que Swagger não substitui o contrato também defende.

Armadilhas depois do “já usei Include”

  • Include em coleção grande + filtro na memória: o SQL traz tudo e o Where no C# descarta;
  • projeção que chama método C# não traduzível: vira client evaluation e às vezes N+1 disfarçado;
  • AsNoTracking em pipeline que depois atualiza a mesma entidade: bug sutil, não ganho;
  • índice novo sem olhar o plano da query que sobrou — otimiza o fantasma do N+1 antigo.

Ordem que paga de verdade

  1. Ligue o log SQL e conte comandos num request real.
  2. Mate o N+1 com projeção (ou Include se o grafo for o produto).
  3. Meça de novo; compare com o baseline.
  4. Só então microdetalhe de CPU, serializer, pooling, etc.

Performance de borda sem olhar o banco é o caminho mais caro para comemorar 2% enquanto sobram 200 round-trips. Comece pela contagem de DbCommand.

Fontes: EF Core eager loading, efficient querying. Equipe DevBras.

Avalie este artigo

Referência: https://docs.microsoft.com/pt-br/aspnet/core/performance/performance-best-practices