IEnumerable and IQueryable

#dotnet #collection #csharp

IEnumerable and IQueryable

In C#, both IEnumerable and IQueryable are interfaces that allow you to work with collections of objects, but they differ in terms of how they retrieve data.

IEnumerable is defined in the System.Collections namespace and is the base interface for all non-generic collections that can be enumerated. When you work with an IEnumerable, you are working with an in-memory collection of objects that are already loaded into memory. You can use the foreach loop to iterate over the collection and access each element in turn.

Here is an example of using IEnumerable in C#:

IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

foreach (int num in numbers)
{
    Console.WriteLine(num);
}

In the above example, we create an IEnumerable collection of integers and use the foreach loop to iterate over each element and print it to the console.

IQueryable, on the other hand, is defined in the System.Linq namespace and is used to query data from a data source, such as a database, rather than working with an in-memory collection. When you work with an IQueryable, you are creating a query that is executed when you actually enumerate the results.

Here is an example of using IQueryable in C#:

IQueryable<Customer> customers = db.Customers.Where(c => c.City == "London");

foreach (Customer customer in customers)
{
    Console.WriteLine(customer.Name);
}

In the above example, we create an IQueryable collection of Customer objects and use the Where method to filter the results to only those customers who live in London. The query is not executed until we enumerate the results using the foreach loop.

Note that IQueryable also supports deferred execution, which means that the query is not actually executed until you try to access the results. This can be useful when working with large datasets that may take a long time to retrieve from a data source.

IEnumerable and IQueryable are both interfaces in C# that allow you to work with collections of objects, but they differ in terms of how they retrieve data. Let's take a closer look at the internals of these interfaces.

IEnumerable is defined in the System.Collections namespace and is the base interface for all non-generic collections that can be enumerated. It has a single method, GetEnumerator(), which returns an IEnumerator object that can be used to iterate over the collection. When you use foreach to iterate over an IEnumerable, the compiler generates code that calls GetEnumerator() and uses the MoveNext() and Current properties of the IEnumerator to iterate over the collection.

Here is an example of how IEnumerable works internally:

IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

IEnumerator<int> enumerator = numbers.GetEnumerator();

while (enumerator.MoveNext())
{
    int num = enumerator.Current;
    Console.WriteLine(num);
}

In the above example, we create an IEnumerable collection of integers and use the GetEnumerator() method to get an IEnumerator object. We then use the MoveNext() and Current properties of the IEnumerator to iterate over the collection and print each element to the console.

IQueryable, on the other hand, is defined in the System.Linq namespace and is used to query data from a data source, such as a database. It extends IEnumerable and adds methods for filtering, sorting, and projecting data before it is retrieved from the data source. When you use IQueryable, you are creating a query that is executed when you actually enumerate the results.

Here is an example of how IQueryable works internally:

IQueryable<Customer> customers = db.Customers.Where(c => c.City == "London");

IEnumerator<Customer> enumerator = customers.GetEnumerator();

while (enumerator.MoveNext())
{
    Customer customer = enumerator.Current;
    Console.WriteLine(customer.Name);
}

In summary, IEnumerable is used to work with in-memory collections, whereas IQueryable is used to query data from a data source. IEnumerable is simpler and provides basic functionality for working with collections, whereas IQueryable provides additional functionality for querying data from a data source in a more efficient manner by performing filtering and sorting operations in the data source itself before retrieving the data.

Disclaimer : This article has been written using AI and MSDN resources

Top comments (4)

Owen Shartle • Mar 23 '23

I could be missing something, but the way this is written seems to imply that IEnumerable doesn't support deferred execution and that it too wouldn't "query" when enumerated. To my knowledge we would consider both as built queries that will execute upon enumeration.
[It might depend on the context around the term "query"]

That said, I think the major take away(s) is still evident. That one is working with in-memory collections and the other with remote data sources (out-memory). Due to working with a remote data source the latter, IQueryable, which extends IEnumerable has unique capabilities* like including filters with the remote server-side query (though deferred execution wouldn't necessarily be one of the distinctions, right?).

yogini16 • Mar 24 '23

It's just an overview of both, if we go in depth, there are capabilities of both which are not mentioned. I will try to enhance this article to be more specific

Sloan the DEV Moderator • Mar 22 '23

Hey, this article seems like it may have been generated with the assistance of ChatGPT.

We allow our community members to use AI assistance when writing articles as long as they abide by our guidelines. Could you review the guidelines and edit your post to add a disclaimer?