IEnumerable vs IQueryable

Prev Next

IEnumerable and IQueryable are both interfaces in .NET used to work with collections of data, but they have different purposes and capabilities. Here’s a comparison to help understand their differences.

IEnumerable

Purpose - Represents a sequence of elements that can be enumerated (iterated) one at a time. It is used for working with in-memory collections.
Methods - Provides methods for iterating and querying collections, such as Where, Select, and ToList.
Execution - Executes queries immediately (eagerly). When you use LINQ methods on IEnumerable, the query is executed when you iterate over the collection.
Usage - Ideal for in-memory collections like arrays, lists, and other data structures that are already loaded in memory.:

Example

IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList(); // Query is executed immediately

IQueryable

Purpose - Represents a queryable collection that can be queried using LINQ. It is often used with data sources that support querying, like databases or remote services.
Methods - Extends IEnumerable with additional methods for building and executing queries, such as Where, Select, OrderBy, and Take.
Execution - Supports deferred execution. Queries are built up in a query expression tree and are not executed until you iterate over the results.
Usage - Ideal for querying data sources that support query translation, like Entity Framework or other ORMs, which can translate LINQ queries into SQL queries.

Example

IQueryable<int> numbers = dbContext.Numbers; // Assume dbContext.Numbers is an IQueryable
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList(); // Query is translated to SQL and executed on the database

Difference Between IEnumerable vs IQueryable

IEnumerable	IQueryable
In-memory sequence of elements.	Queryable data source, typically for databases.
LINQ methods that operate on in-memory data.	LINQ methods that build and execute queries on data sources.
Eager execution: queries are executed immediately.	Deferred execution: queries are built but not executed until needed.
Ideal for collections that are already loaded in memory.	Ideal for querying databases or other data sources where queries can be translated into a native query language.
May be less efficient for large datasets or remote data sources because it processes data in-memory.	Can be more efficient for large datasets or remote data sources as queries are executed on the server-side.

When to Use Each

IEnumerable - Use it when working with in-memory collections or when you don’t need to defer execution or leverage query translation. It’s suitable for collections already loaded into memory, where you need immediate results.
IQueryable - Use it when you need to query data from a data source that supports query translation (like a database) and you want to leverage deferred execution. It is ideal for scenarios where you need to build up queries dynamically or work with large datasets where the query should be executed on the server.