Por que uma tela simples pode disparar dezenas de consultas ao banco de dados?
O problema nem sempre é a quantidade de dados. Às vezes, são as perguntas que fazemos ao banco.

Imagine que você está desenvolvendo um painel administrativo para uma loja virtual.
A tela apresenta os últimos pedidos, o nome dos clientes, os valores e as datas de compra.
Você faz uma consulta ao banco de dados, recebe os pedidos e monta a lista. Tudo funciona perfeitamente durante os testes.
Mas, quando a aplicação começa a receber mais dados, a tela fica lenta.
Você verifica o frontend, otimiza os componentes e até reduz algumas operações desnecessárias. Mesmo assim, o problema continua.
Talvez o gargalo não esteja na interface, mas na maneira como sua aplicação consulta o banco de dados.
Um dos problemas que pode causar esse comportamento é conhecido como N+1 Query Problem.
O que é o problema N+1?
Imagine que você precisa consultar 50 pedidos e apresentar o nome de cada cliente.
Uma implementação pouco cuidadosa pode fazer o seguinte:
Executar uma consulta para buscar os 50 pedidos.
Executar outra consulta para descobrir o cliente de cada pedido.
No final, teremos:
1 consulta para buscar os pedidos.
50 consultas para buscar os clientes.
Quantidade de consultas:
Operação | Consultas |
|---|---|
Buscar os pedidos | 1 |
Buscar os clientes | 50 |
Total | 51 |
Exemplo ilustrativo com 50 pedidos e uma consulta individual para cada cliente.
Esse é o problema N+1: uma consulta inicial acompanhada de N consultas adicionais para buscar informações relacionadas.
Para entender melhor, imagine que você está organizando uma lista de convidados para uma festa.
Em vez de pegar a lista completa com os nomes e contatos, você busca a lista de convidados e, depois, precisa consultar individualmente o telefone de cada pessoa.
Se forem 50 convidados, serão 50 buscas adicionais.
O problema não está necessariamente na quantidade de informações, mas na quantidade de operações necessárias para obtê-las.
Como isso acontece no C# e Entity Framework Core?
Vamos imaginar uma entidade de pedidos (Order) e outra de clientes (Customer).
Uma primeira implementação poderia ser:
var orders = await db.Orders
.ToListAsync();
var result = new List<OrderSummary>();
foreach (var order in orders)
{
var customer = await db.Customers
.FirstOrDefaultAsync(
c => c.Id == order.CustomerId
);
result.Add(new OrderSummary(
order.Id,
customer?.Name ?? "Cliente não encontrado",
order.Total
));
}O código parece organizado.
Primeiro buscamos os pedidos. Depois percorremos cada um e encontramos o cliente correspondente.
O problema é que estamos executando uma nova consulta ao banco dentro de um loop.
Se encontrarmos 50 pedidos, teremos uma consulta inicial e outras 50 consultas individuais.
E se forem 500 pedidos?
A lógica continua funcionando, mas o número de operações aumenta junto com a quantidade de registros.
Esse tipo de problema pode passar despercebido durante o desenvolvimento, principalmente quando os testes utilizam poucos dados.
O N+1 também pode acontecer sem um loop explícito
Outra situação que merece atenção é o chamado lazy loading (carregamento tardio).
Imagine que você carregue uma lista de pedidos e, posteriormente, acesse order.Customer.Name para apresentar o nome de cada cliente.
Se o lazy loading estiver habilitado, o Entity Framework Core poderá buscar o cliente automaticamente quando essa propriedade for acessada.
O resultado pode ser o mesmo: uma consulta inicial para os pedidos e várias consultas adicionais para os clientes.
Por isso, nem sempre o problema está em um código que aparentemente faz muitas consultas. Às vezes, elas são executadas automaticamente pelo mecanismo de carregamento de relacionamentos.
Como resolver utilizando Entity Framework Core?
Uma alternativa é utilizar Include() para carregar também as informações relacionadas.
var orders = await db.Orders
.Include(order => order.Customer)
.AsNoTracking()
.ToListAsync();O Include() informa ao Entity Framework Core que também queremos carregar a entidade relacionada.
Assim, podemos acessar o cliente diretamente:
foreach (var order in orders)
{
Console.WriteLine(order.Customer.Name);
}Em uma consulta simples desse tipo, considerando um relacionamento de referência entre pedido e cliente, o EF Core normalmente utiliza um JOIN para buscar as informações relacionadas em uma única consulta SQL.
O AsNoTracking() também é interessante nesse cenário, porque estamos apenas lendo informações e não precisamos acompanhar as alterações das entidades pelo mecanismo de tracking do Entity Framework.
Vale lembrar que o Include() não garante uma única consulta em todos os cenários. Quando existem relacionamentos mais complexos, especialmente várias coleções, o EF Core pode executar consultas separadas, dependendo da configuração utilizada.
Busque apenas as informações que realmente precisa
Imagine que nossa tela apresenta apenas três informações:
Número do pedido.
Nome do cliente.
Valor total.
Precisamos carregar todas as propriedades das entidades Order e Customer para apresentar esses dados?
Provavelmente não.
Podemos utilizar Select() para projetar diretamente o resultado:
var orders = await db.Orders
.AsNoTracking()
.Select(order => new OrderSummary(
order.Id,
order.Customer.Name,
order.Total
))
.ToListAsync();Agora estamos dizendo ao Entity Framework Core exatamente quais informações queremos receber.
Em consultas desse tipo, o EF Core consegue traduzir o acesso à navegação Customer.Name para SQL, geralmente utilizando um JOIN.
Isso evita carregar propriedades que não serão utilizadas na tela.
Também deixa mais clara a intenção da consulta: estamos buscando informações para apresentar um resumo de pedidos, não necessariamente carregando todas as entidades completas.
Essa técnica é conhecida como projeção de dados.
Em vez de trazer todos os dados e decidir depois o que utilizar, selecionamos antecipadamente apenas as informações necessárias.
Então devemos sempre utilizar Select em vez de Include?
Não necessariamente.
Cada abordagem possui uma finalidade.
Include() faz sentido quando precisamos carregar entidades relacionadas e trabalhar com elas como objetos completos.
Select() costuma ser uma boa escolha quando precisamos montar uma resposta específica, como um DTO (Data Transfer Object) para uma API.
Por exemplo, uma tela de relatório pode precisar apenas do nome do cliente, do total de vendas e da data do pedido. Carregar todas as informações de cada entidade seria trabalho desnecessário.
Também precisamos ter cuidado com relacionamentos mais complexos. Carregar várias coleções com Include() pode aumentar bastante o volume de dados retornados e até gerar duplicação de linhas no resultado SQL.
Dependendo do cenário, projeções ou consultas divididas podem ser mais adequadas.
O importante é entender o que a aplicação realmente precisa e escolher a estratégia de consulta de acordo com esse objetivo.
Como identificar esse problema na prática?
Uma boa maneira é observar as consultas que sua aplicação realmente executa.
O Entity Framework Core oferece recursos de logging que permitem acompanhar os comandos SQL enviados ao banco.
Por exemplo:
optionsBuilder.LogTo(
Console.WriteLine,
LogLevel.Information
);Com isso, podemos visualizar as consultas executadas durante o desenvolvimento e identificar operações repetidas.
Também podemos utilizar ferramentas como SQL Server Profiler e os recursos de monitoramento do próprio banco de dados.
Se uma tela que deveria realizar poucas operações estiver disparando dezenas ou centenas de consultas semelhantes, vale investigar se existe um problema N+1.
Outro cuidado importante é não depender apenas dos dados de desenvolvimento.
Uma tela que apresenta cinco pedidos pode funcionar perfeitamente, enquanto a mesma implementação, com centenas de pedidos, apresenta problemas de desempenho.
Por isso, testar com volumes de dados próximos da realidade é fundamental.
Para finalizar
Nem sempre uma aplicação fica lenta porque o banco de dados é ruim ou porque precisamos de um servidor mais potente.
Às vezes, o problema está na maneira como estamos solicitando as informações.
Entender como funcionam os relacionamentos, as consultas e a projeção de dados ajuda a construir aplicações mais eficientes e previsíveis.
Antes de tentar acelerar o banco de dados, descubra quantas vezes sua aplicação está pedindo a mesma informação.
Projetos
Precisa desenvolver ou melhorar uma aplicação?
Conheça meus projetos ou entre em contato para conversar sobre sua necessidade.