In C#, the variety of collection interfaces and classes can sometimes be overwhelming, especially for developers new to the language. Understanding the differences between IEnumerable, ICollection, IList, and List is crucial for writing efficient and maintainable code. Each plays a specific role, and knowing when to use each can make a big difference in your application’s performance and clarity.
In this article, we’ll break down these types, their key differences, and when to use each.
1. IEnumerable
Definition:
IEnumerable is the most basic collection interface in C#. It represents a sequence of elements that can be enumerated. It is read-only, meaning you can iterate over the elements but cannot modify them.
Key Features:
- Provides a simple way to iterate over a collection using
foreach
. - Does not support random access (e.g., accessing elements by index).
- Found in the
System.Collections
namespace for non-generic types and inSystem.Collections.Generic
for generic types (IEnumerable<T>
).
Example:
IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (var num in numbers)
{
Console.WriteLine(num);
}
Use Case:
Use IEnumerable when you only need to iterate through a collection.
More Resources:
To dive deeper into IEnumerable, check out this comprehensive guide on IEnumerable in C#.
2. ICollection
Definition:
ICollection extends IEnumerable by adding methods to manipulate the collection, such as adding, removing, or checking the count of elements. It serves as the base interface for most collection types in .NET.
Key Features:
- Supports operations like
Add
,Remove
, andClear
. - Provides the
Count
property to get the number of elements. - Still does not support random access by index.
Example:
ICollection<string> fruits = new List<string> { "Apple", "Banana" };
fruits.Add("Orange");
Console.WriteLine(fruits.Count); // Output: 3
Use Case:
Use ICollection when you need to modify the collection but don’t need index-based access.
3. IList
Definition:
IList extends ICollection by introducing index-based access, allowing you to get, set, or insert elements at a specific position.
Key Features:
- Provides methods like
Insert
andRemoveAt
. - Allows indexed access via the
[]
operator. - Found in the
System.Collections
(non-generic) andSystem.Collections.Generic
namespaces.
Example:
IList<int> numbers = new List<int> { 10, 20, 30 };
numbers.Insert(1, 15);
Console.WriteLine(numbers[1]); // Output: 15
Use Case:
Use IList when you need to modify the collection and access elements by index.
4. List
Definition:
List is a concrete implementation of IList and ICollection. It is one of the most commonly used collection types in C#. Being a generic class (List<T>
), it offers strong type safety and high performance for many scenarios.
Key Features:
- Provides a robust implementation of IList with additional utility methods such as
Find
,Sort
, andReverse
. - Dynamically resizes as elements are added or removed.
- Allows duplication of elements.
Example:
List<string> animals = new List<string> { "Dog", "Cat" };
animals.Add("Bird");
animals.Sort();
foreach (var animal in animals)
{
Console.WriteLine(animal);
}
Use Case:
Use List when you need a flexible, high-performance collection that supports indexing, dynamic resizing, and rich methods.
Summary Table
Feature | IEnumerable | ICollection | IList | List |
---|---|---|---|---|
Namespace | System.Collections / System.Collections.Generic | System.Collections.Generic | System.Collections.Generic | System.Collections.Generic |
Iteration | Yes | Yes | Yes | Yes |
Modification | No | Yes | Yes | Yes |
Index Access | No | No | Yes | Yes |
Common Usage | Read-only iteration | General collection manipulation | Indexed access | Versatile, dynamic collection |
When to Use Each
- IEnumerable: When you only need to read and iterate over a collection (e.g., LINQ queries).
- ICollection: When you need to modify a collection but don’t require indexed access.
- IList: When you need to modify and access elements by index.
- List: When you need a flexible and fully-featured collection.
Conclusion
Understanding the differences between IEnumerable, ICollection, IList, and List is essential for choosing the right collection type for your C# projects. Each has its strengths and is suited for specific use cases, from simple iteration to complex manipulation.
For more insights into IEnumerable and how it fits into this hierarchy, visit the ByteHide blog on IEnumerable in C#. By mastering these collection types, you’ll be able to write cleaner, more efficient, and maintainable code.