ICollection vs IQueryable vs IEnumerable vs IList vs List vs HashSet in C#

                                   

When working with data in C#, choosing the proper collection type is critical for achieving best performance, maintainability, and code clarity. This article discusses collection interfaces and types in C#, including differences, use cases, and recommended practices.

IEnumerable

Definition: Represents a sequence of elements that can be enumerated.

Key Features:

  • Supports simple iteration over a collection using foreach.
  • Provides deferred execution when used with LINQ.
  • Read-only; does not support adding or removing elements.

When to Use:

  • Ideal for exposing data that does not need to be modified.
  • Suitable for querying collections using LINQ.
IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (var number in numbers)
{
    Console.WriteLine(number);
}

IReadOnlyCollection

Definition: Represents a read-only collection of elements.

Key Features:

  • Extends IEnumerable and includes a Count property.
  • Guarantees immutability (the collection cannot be modified).

When to Use:

  • When you want to expose a collection with a count but prevent modifications.
IReadOnlyCollection<int> readOnlyNumbers = new List<int> { 1, 2, 3 };
Console.WriteLine(readOnlyNumbers.Count);

ICollection

  • Definition: Represents a collection of elements that can be modified.

Key Features:

  • Extends IEnumerable and provides methods like Add, Remove, and Clear.
  • Includes a Count property.

When to Use:

  • For scenarios where you need to modify the collection (e.g., add or remove elements).
ICollection<string> names = new List<string> { "Alice", "Bob" };
names.Add("Charlie");
Console.WriteLine(names.Count);

IQueryable

Definition: Represents a queryable data source.

Key Features:

  • Extends IEnumerable and provides LINQ support for querying data sources.
  • Enables deferred execution and translation of LINQ queries into SQL or other formats (e.g., with Entity Framework).

When to Use:

  • For querying data from remote sources like databases.
IQueryable<int> queryableData = new List<int> { 1, 2, 3 }.AsQueryable();
var filteredData = queryableData.Where(x => x > 1);
foreach (var item in filteredData)
{
    Console.WriteLine(item);
}

IReadOnlyList

Definition: Represents a read-only list of elements.

Key Features:

  • Extends IReadOnlyCollection and provides indexed access to elements.
  • Ensures the collection cannot be modified.

When to Use:

  • When you need indexed access but want to ensure immutability.
IReadOnlyList<int> readOnlyList = new List<int> { 1, 2, 3 };
Console.WriteLine(readOnlyList[0]);

Array

Definition: Represents a fixed-size, strongly-typed collection of elements.

Key Features:

  • Supports fast indexed access.
  • Fixed size; cannot dynamically add or remove elements.

When to Use:

  • For collections with a known, fixed size.
  • When performance is critical and resizing is not required.
int[] numbers = { 1, 2, 3 };
Console.WriteLine(numbers[1]);

IList

Definition: Represents a list of elements that can be accessed by index.

Key Features:

  • Extends ICollection and adds methods for indexed access and insertion.
  • Allows dynamic resizing.

When to Use:

  • When you need dynamic resizing and indexed access.
IList<string> fruits = new List<string> { "Apple", "Banana" };
fruits.Add("Cherry");
Console.WriteLine(fruits[2]);

Best Practices

  • IEnumerable when you only need to iterate over a collection.
  • IReadOnlyCollection or IReadOnlyList to expose data without allowing modifications.
  • ICollection or IList when you need to modify the collection.
  • IQueryable for LINQ-to-SQL or similar scenarios.
  • Arrays for fixed-size collections where performance is critical.

Conclusion

Choosing the right collection type in C# is essential for writing efficient and maintainable code. To achieve this, assess your requirements for mutability, performance, and access patterns. For instance, use IEnumerable for read-only iteration, IQueryable for database queries, and IList when dynamic resizing and indexed access are needed. Understanding these distinctions ensures you make optimal design choices

Happy Coding !! 



Comments

Post a Comment

Popular posts from this blog

Deferred Execution in .NET:

Image
One of the core ideas in .NET is deferred execution, which has major advantages for memory management, performance, and overall code efficiency. Developers can create code that is clearer and more efficient by comprehending and utilizing postponed execution. To help you get the most out of this potent feature, we will go over what deferred execution is, how it functions in.NET, and several real-world use cases in this blog. What is Deferred Execution? The process of delaying the assessment of a query or operation until its outcomes are truly required is known as deferred execution. In other words, a query's processing or execution is postponed until it is iterated or accessed, rather than occurring at the point of definition. Although it can be used to various situations, this idea is most frequently linked to LINQ (Language Integrated Query) in.NET. How Deferred Execution Works When defined, LINQ queries in.NET do not run right away. Rather, they produce an iterator or an expressi...
Read more

Why Async/Await Don't Work With Array Methods in .NET

Image
 Because of its many advantages in terms of scalability and responsiveness, asynchronous programming in.NET has become a standard feature in modern application development. However, attempting to utilize async/await with array methods like ForEach, Select, or Map (in contexts inspired by JavaScript) is one of the main mistakes that developers face. In addition to offering workable options for managing asynchronous actions with collections in.NET, this article investigates why this method doesn't function as intended. Understanding the Problem Array Methods and Delegates Array methods in .NET, such as ForEach or LINQ’s Select, are designed to execute synchronously. For example: These methods allow you to pass a delegate (like a lambda function) that is either executed sequentially or in a manner that follows the method's design. The compiler allows the usage of an async lambda but gives a warning if you try to do so: LINQ and Deferred Execution LINQ methods like Select and Where...
Read more