Mastering IEnumerable And IQueryable With Complex Type

Jump To Right Section Show

In C#, when working with collections, querying, and manipulating data, two important interfaces come into play: IEnumerable and IQueryable. Although they might seem similar at first, they have distinct characteristics and are used in different scenarios. Similarly, with the help of the generic type parameter <T>, both IEnumerable and IQueryable interfaces can handle complex types efficiently.

This article will explore the differences between IEnumerable and IQueryable and provide practical examples to explain their usages and capabilities with complex types using IEnumerable<T> and IQueryable<T>.

What is IEnumerable in C#?

IEnumerable is the simplest and most common interface for working with collections in C#. It is suitable for working with small in-memory collections and performing basic operations like filtering, sorting, and projecting/iterating data. The IEnumerable interface is a type of iteration design pattern. It means we can iterate on the collection of the type IEnumerable.

IEnumerable: The Foundation of In-Memory Collections

The IEnumerable interface is a fundamental part of C# collections. It provides a simple and intuitive way to work with in-memory data. Here are the key aspects of IEnumerable:

Basic Functionality: IEnumerable offers read-only and forward-only traversal through a collection of data.
Namespace: IEnumerable resides in the System.Collections namespace.
In-Memory Operations: It supports querying and manipulating data in-memory, making it ideal for small collections.

Let’s look at an example to demonstrate IEnumerable:


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

IEnumerable<int> evenNumbers = numbers.Where(x => x % 2 == 0);
foreach (int number in evenNumbers)
{
    Console.WriteLine(number);
}

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

IEnumerable<int> evenNumbers = numbers.Where(x => x % 2 == 0);

foreach (int number in evenNumbers)

{

Console.WriteLine(number);

}

In this example, we have a list of numbers, and using the Where extension method from IEnumerable, we filter even numbers. The resulting IEnumerable is then iterated using a foreach loop, printing each even number to the console.

IEnumerable<T>: Working with Complex Type Collections

The IEnumerable<T> interface extends the capabilities of IEnumerable to work with collections of complex types. Let’s take a look at its key features:

Generic Type Parameter: IEnumerable<T> allows us to work with collections of a specific complex type, denoted by the generic type parameter <T>.
In-Memory Operations: Similar to IEnumerable, IEnumerable<T> supports querying and manipulating data in-memory collections.
Type Safety: By specifying the complex type using <T>, IEnumerable<T> provides type safety and enables the use of strongly typed operations.

Let’s illustrate IEnumerable<T> with a complex type example:


IEnumerable<Person> persons = new List<Person>
{
    new Person { Name = "John", Age = 25 },
    new Person { Name = "Alice", Age = 30 },
    new Person { Name = "Bob", Age = 28 }
};

IEnumerable<Person> adults = persons.Where(p => p.Age >= 18);
foreach (Person person in adults)
{
    Console.WriteLine($"{person.Name} - {person.Age}");
}

IEnumerable<Person> persons = new List<Person>

{

new Person { Name = "John", Age = 25 },

new Person { Name = "Alice", Age = 30 },

new Person { Name = "Bob", Age = 28 }

};

IEnumerable<Person> adults = persons.Where(p => p.Age >= 18);

foreach (Person person in adults)

{

Console.WriteLine($"{person.Name} - {person.Age}");

}

In this example, we have a list of Person objects. By specifying Person as the generic type parameter when declaring the IEnumerable<Person>, we can leverage its properties (Name and Age) for filtering. Using the Where extension method, we filter and retrieve only the adults (persons with an age of 18 or above), which are then printed to the console.

What is IQueryable in C#?

IQueryable is an interface that extends IEnumerable and provides additional capabilities for querying data. It supports querying data from various sources like databases, remote APIs, or other queryable data providers. It is suitable for working with large datasets and performing complex querying operations.

IQueryable: Unleashing the Power of Querying

While IEnumerable is suitable for in-memory collections, IQueryable takes querying to another level. It extends IEnumerable and adds powerful capabilities for querying diverse data sources. Here’s what you need to know about IQueryable:

Advanced Querying: IQueryable enables querying of various data sources, such as databases, remote APIs, or any other queryable providers.
Namespace: IQueryable resides in the System.Linq namespace.
Efficient Execution: It utilizes query providers (e.g., LINQ-to-SQL or LINQ-to-Entities) to translate the query expressions into optimized representations specific to the data source. This ensures efficient execution, especially when dealing with large datasets.

To illustrate IQueryable, consider the following example:


IQueryable<int> numbers = dbContext.Numbers;

IQueryable<int> evenNumbers = numbers.Where(x => x % 2 == 0);
foreach (int number in evenNumbers)
{
    Console.WriteLine(number);
}

IQueryable<int> numbers = dbContext.Numbers;

IQueryable<int> evenNumbers = numbers.Where(x => x % 2 == 0);

foreach (int number in evenNumbers)

{

Console.WriteLine(number);

}

In this case, dbContext.Numbers represents a queryable data source, such as a database table. Using the Where method from IQueryable, we filter even numbers. The query is executed in a deferred manner, and the result is retrieved and iterated over.

IQueryable<T>: Complex Type Querying Powerhouse

When it comes to querying complex types from various data sources, IQueryable<T> provides powerful capabilities. Let’s explore its characteristics:

Generic Type Parameter: IQueryable<T> is also generic and allows working with collections of complex types, just like IEnumerable<T>.
Query Providers: IQueryable<T> leverages query providers (e.g., LINQ-to-SQL, LINQ-to-Entities) to translate query expressions into optimized representations specific to the data source.
Deferred Execution: Query expressions written using IQueryable<T> are executed in a deferred manner, allowing for efficient retrieval of data from large datasets.

Consider the following example to demonstrate IQueryable<T> with complex types:


IQueryable<Person> persons = dbContext.Persons;

IQueryable<Person> adults = persons.Where(p => p.Age >= 18);
foreach (Person person in adults)
{
    Console.WriteLine($"{person.Name} - {person.Age}");
}

IQueryable<Person> persons = dbContext.Persons;

IQueryable<Person> adults = persons.Where(p => p.Age >= 18);

foreach (Person person in adults)

{

Console.WriteLine($"{person.Name} - {person.Age}");

}

In this scenario, dbContext.Persons represent a queryable data source, such as a database table. By using the Where method from IQueryable<T>, we filter and retrieve the adult persons. The query is executed efficiently, thanks to the underlying query provider, and the results are iterated over and printed to the console.

Understanding the differences between IEnumerable and IQueryable is crucial for efficient data manipulation and querying in C#. While IEnumerable is suitable for in-memory collections and basic operations, IQueryable expands the possibilities by leveraging query providers and enabling querying across various data sources. Similarly, IEnumerable<T> is perfect for in-memory collections, while IQueryable<T> shines when querying data from diverse sources. With these interfaces, you can write efficient and scalable code that meets the specific requirements of your applications.

Back to Course Content