Blog

IEnumerable vs IQueryable: uma diferença que pode mudar o desempenho da sua aplicação

Buscar tudo para filtrar depois também tem um custo.

8 min de leiturapor Leonardo Padilha
Capa do artigo IEnumerable vs IQueryable: uma diferença que pode mudar o desempenho da sua aplicação

Imagine que você está desenvolvendo uma API para consultar os pedidos de uma loja virtual.

O sistema possui milhares de registros, mas o usuário quer visualizar apenas os pedidos pagos que ultrapassaram determinado valor.

Você escreve uma consulta utilizando LINQ, tudo funciona e os resultados estão corretos.

Só existe um detalhe: sua aplicação está trazendo milhares de registros do banco para depois filtrar tudo na memória.

O problema pode estar em uma escolha aparentemente pequena: utilizar IEnumerable ou IQueryable.

Os dois permitem trabalhar com sequências de dados e utilizar LINQ, mas existe uma diferença importante na maneira como as operações são construídas e executadas.

Primeiro, vamos entender a diferença

Antes de comparar os dois, precisamos entender onde acontece o processamento.

Imagine que você precisa encontrar todos os livros de uma biblioteca que foram publicados depois de 2020.

Existem duas maneiras de realizar essa tarefa:

  • Pedir para trazer todos os livros da biblioteca e depois procurar aqueles que atendem ao critério.

  • Solicitar diretamente ao sistema da biblioteca que encontre apenas os livros publicados depois de 2020.

Nos dois casos, você chega ao resultado desejado. A diferença está em quem realiza o trabalho e em quantas informações precisam ser movimentadas.

É justamente nesse ponto que IEnumerable e IQueryable começam a se diferenciar.

IEnumerable: representa uma sequência de elementos que pode ser percorrida. Quando utilizamos LINQ com essa interface, as operações são executadas pela aplicação, utilizando LINQ to Objects.

IQueryable: representa uma consulta que pode ser descrita por meio de uma árvore de expressões e interpretada por um provedor. Em vez de executar imediatamente cada operação, o LINQ constrói uma expressão que o provedor pode interpretar.

No Entity Framework Core, esse provedor consegue traduzir diversas operações LINQ para SQL.

1. IEnumerable: quando o processamento acontece na aplicação

Vamos começar com um exemplo.

Imagine que temos uma coleção de pedidos e queremos encontrar aqueles que ultrapassaram R$ 500.

IEnumerable<Order> orders = db.Orders;

var expensiveOrders = orders
    .Where(order => order.Total > 500)
    .ToList();

O código parece correto, mas existe um detalhe importante.

Como declaramos orders como IEnumerable, o método Where() utilizado será o do LINQ to Objects.

Isso significa que o filtro será aplicado pela aplicação, e não incorporado à consulta SQL do Entity Framework Core.

Mas atenção: os pedidos ainda não foram carregados quando declaramos a variável.

A consulta original continua sendo executada de maneira adiada. Quando chamamos ToList(), o EF Core busca os registros no banco e, durante a enumeração, o Where() aplica o filtro na aplicação.

Se existirem 10 mil pedidos, podemos acabar transferindo todos eles para depois selecionar apenas aqueles que ultrapassaram R$ 500.

Isso pode gerar um desperdício considerável de memória, processamento e comunicação com o banco.

Voltando ao exemplo da biblioteca, seria como pedir que entregassem todos os livros disponíveis na sua casa para só então separar aqueles publicados depois de 2020.

O resultado estaria correto, mas o trabalho seria muito maior do que o necessário.

Uma observação importante: IEnumerable não significa necessariamente que os dados já estão carregados na memória. O que determina onde o filtro será executado é a implementação do método LINQ utilizada e a origem dos dados.

2. IQueryable: deixando o banco fazer o trabalho

Agora vamos utilizar IQueryable.

IQueryable<Order> orders = db.Orders;

var expensiveOrders = await orders
    .Where(order => order.Total > 500)
    .ToListAsync();

A diferença está na maneira como a consulta é construída.

O Where() não percorre imediatamente os pedidos. Ele adiciona uma condição à expressão da consulta.

Quando chamamos ToListAsync(), o Entity Framework Core interpreta essa expressão, traduz a operação para SQL e executa a consulta no banco.

O resultado será semelhante a:

SELECT *
FROM Orders
WHERE Total > 500;

Agora o banco de dados realiza o filtro antes de devolver os resultados.

Se existem 10 mil pedidos, mas apenas 200 atendem à condição, a aplicação recebe somente os registros correspondentes.

Isso reduz o volume de dados transferidos e evita carregar informações desnecessárias.

Voltando à biblioteca, agora você não precisa levar todos os livros para casa. Basta solicitar ao sistema uma pesquisa com os critérios desejados.

É importante entender que IQueryable não significa automaticamente banco de dados. Ele depende de um provedor capaz de interpretar e executar a expressão. No nosso exemplo, esse provedor é o Entity Framework Core.

3. Mas existe algo ainda mais interessante: combinar consultas

Uma das vantagens de IQueryable é poder construir uma consulta aos poucos.

Imagine que temos uma tela administrativa com filtros opcionais:

  • Situação do pedido.

  • Valor mínimo.

  • Data de criação.

  • Identificação do cliente.

Em vez de criar várias consultas diferentes, podemos adicionar condições conforme os filtros recebidos.

IQueryable<Order> query = db.Orders;

if (status != null)
{
    query = query.Where(
        order => order.Status == status
    );
}

if (minimumValue.HasValue)
{
    query = query.Where(
        order => order.Total >= minimumValue.Value
    );
}

if (customerId.HasValue)
{
    query = query.Where(
        order => order.CustomerId == customerId.Value
    );
}

var orders = await query.ToListAsync();

Perceba que ainda não buscamos os dados quando adicionamos os filtros.

Estamos apenas construindo a consulta.

Quando chegamos ao ToListAsync(), o Entity Framework Core executa a operação com as condições acumuladas.

Imagine novamente uma biblioteca.

Você começa procurando livros publicados depois de 2020. Depois decide que quer apenas aqueles de ficção. Por último, adiciona um filtro para encontrar livros de determinado autor.

Em vez de realizar três pesquisas separadas, você vai refinando a mesma pesquisa até chegar ao resultado desejado.

É exatamente essa flexibilidade que torna IQueryable especialmente útil em telas de pesquisa, relatórios e listagens com filtros dinâmicos.

4. O detalhe que muita gente esquece: nem tudo precisa ir para o banco

Até aqui, vimos como delegar o processamento ao banco de dados pode ajudar no desempenho.

Mas será que sempre devemos fazer isso?

Imagine que sua aplicação possui uma regra específica para identificar pedidos elegíveis a uma campanha.

Essa regra utiliza um método próprio:

bool IsEligibleForCampaign(Order order)
{
    return order.Total > 500 &&
           order.Customer.IsActive;
}

Podemos utilizar esse método em uma coleção local:

var eligibleOrders = orders
    .Where(IsEligibleForCampaign)
    .ToList();

Mas, se tentarmos utilizar diretamente esse método em uma consulta do Entity Framework Core:

var eligibleOrders = await db.Orders
    .Where(order => IsEligibleForCampaign(order))
    .ToListAsync();

Podemos receber uma exceção.

Por quê?

Porque o Entity Framework Core precisa conseguir traduzir a expressão para SQL, e não sabe automaticamente como transformar qualquer método C# em uma instrução SQL.

Nas versões modernas do EF Core, expressões que não podem ser traduzidas e aparecem em filtros normalmente geram uma exceção, em vez de serem silenciosamente executadas na memória.

Uma alternativa é separar as responsabilidades:

var orders = await db.Orders
    .Where(order => order.Total > 500)
    .Include(order => order.Customer)
    .ToListAsync();

var eligibleOrders = orders
    .Where(IsEligibleForCampaign)
    .ToList();

Nesse caso, o banco executa o filtro que consegue traduzir, e a regra personalizada é aplicada depois, na aplicação.

Mas atenção: isso significa que todos os pedidos acima de R$ 500 serão carregados antes da validação personalizada.

Se forem muitos registros, precisamos avaliar outra estratégia.

Uma possibilidade seria transformar a regra em uma expressão que o EF Core consiga traduzir, quando isso for viável. Outra seria implementar a lógica diretamente na consulta, utilizando condições compatíveis com o provedor.

O importante é não transferir grandes volumes de dados para a aplicação sem necessidade.

5. Quando utilizar cada um?

Não existe um vencedor absoluto. A escolha depende de onde estão os dados e de onde queremos executar o processamento.

Situação

Melhor escolha

Filtrar uma lista já carregada

IEnumerable

Construir consultas para o banco

IQueryable

Trabalhar com filtros dinâmicos no EF Core

IQueryable

Processar uma coleção em memória

IEnumerable

Compor consultas antes de executá-las

IQueryable

Existe também um detalhe importante: ambos podem trabalhar com execução adiada.

Métodos como ToList(), ToArray() e First() provocam a execução de uma sequência ou consulta. O momento exato depende do operador e do provedor utilizado.

No caso do EF Core, ToListAsync() executa a consulta de forma assíncrona e materializa os resultados em uma lista.

Outro cuidado é que IQueryable não significa automaticamente banco de dados. Além disso, nem toda expressão pode ser traduzida pelo provedor.

Por fim, IQueryable herda de IEnumerable. Isso significa que uma consulta pode ser percorrida como uma sequência, mas a forma como os métodos LINQ são aplicados pode mudar completamente o comportamento da operação.

Para finalizar

A diferença entre IEnumerable e IQueryable vai muito além de uma questão de sintaxe.

Ela envolve entender onde os dados estão, onde o processamento acontece e quanto trabalho estamos transferindo para a aplicação.

Quando trabalhamos com grandes volumes de informações, essa decisão pode afetar diretamente o consumo de memória, a quantidade de dados transferidos e o desempenho das consultas.

Não basta escrever uma consulta que retorna os dados corretos. Também precisamos pensar em onde essa consulta está sendo executada.

Projetos

Precisa desenvolver ou melhorar uma aplicação?

Conheça meus projetos ou entre em contato para conversar sobre sua necessidade.