Understanding IEnumerable vs. ICollection in .NET

If you’re working with collections in C#, you’ve probably come across IEnumerable and ICollection. But what exactly are they? What are the differences between them, and how do you know which one to use?

This post simplifies the comparison between IEnumerable and ICollection, making it easy to grasp their main features, appropriate usage scenarios, and benefits to your coding practices.

What Are IEnumerable and ICollection?

IEnumerable and ICollection are interfaces in C# designed to facilitate the handling of data groups, such as lists or arrays; by defining the ways you can interact with these collections.

IEnumerable: The IEnumerable interface is fundamental to all collections in .NET. It defines a single method,GetEnumerator() , which returns an enumerator that iterates through a collection.

IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (var number in numbers)
{
    Console.WriteLine(number); // Outputs each number
}

ICollection: The ICollection interface extends IEnumerable and adds more capabilities, such as modifying the collection and querying its size.

1
2
3

ICollection<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Add(6); // Adds an element
Console.WriteLine(numbers.Count); // Outputs 6

When can we use IEnumerable?

IEnumerable is great for scenarios where you just want to look at or read the data without making changes. Here’s when you should use it:

Reading data only: If you only need to go through a list of data without modifying it, IEnumerable is perfect.

using System;
using System.Collections.Generic;

class Program
{
  static void Main()
  {
    IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

    foreach (var number in numbers)
    {
      Console.WriteLine(number); // Just reading each item
    }
  }
}

When Performance is Critical for Large Datasets: IEnumerable employs a technique known as lazy loading, which means it retrieves data only when necessary. This approach can conserve memory when dealing with large datasets.
Looping through items: If your main goal is to loop through a collection, like data from a database or an API, and not change it, IEnumerable will do the job.

using System;
using System.Collections.Generic;

class Program
{
  static void Main()
  {
    // Simulate retrieving data from a database or API
    IEnumerable<string> dataFromDatabase = GetData();

    // Loop through the data using IEnumerable
    foreach (var item in dataFromDatabase)
    {
      Console.WriteLine(item);
    }
  }

  // Simulated method to return data
  static IEnumerable<string> GetData()
  {
    // In a real-world application, this might query a database or call an API
    return new List<string> { "Item 1", "Item 2", "Item 3", "Item 4" };
  }
}

In this code, we use Enumerable to loop through a list of string. We can’t change the list, just read through it. GetData() could be anything, either from database or API data.

When Using Custom Iterators: The yield return statement in C# is used to create custom iterators, which typically implement IEnumerable. This is useful when generating sequences of data dynamically.

public static IEnumerable<int> GetSquares(int max)
{
  for (int i = 1; i <= max; i++)
  {
    yield return i * i;
  }
}

var squares = GetSquares(5);
foreach (var square in squares)
{
  Console.WriteLine(square);
}

Working with LINQ Queries: LINQ methods such as Select, Where, and OrderBy often return IEnumerable. These queries support deferred execution, meaning they are executed only when enumerated, which can improve performance for large datasets.

IEnumerable<int> evenNumbers = Enumerable.Range(1, 10).Where(n => n % 2 == 0);
foreach (var number in evenNumbers)
{
  Console.WriteLine(number); // Outputs even numbers between 1 and 10
}

When can we use ICollection?

ICollection is the go-to option when you need more than just looking at the data. It extends IEnumerable by adding features for modifying collections, querying metadata, and supporting synchronization. Here are the scenarios where ICollection is the most appropriate choice:

You need to modify the collection: If you want to add new items or remove items from a list, ICollection provides methods like Add, Remove, and Clear.

ICollection<string> names = new List<string> { "Alice", "Bob" };
names.Add("Charlie");
names.Remove("Bob");

foreach (var name in names)
{
  Console.WriteLine(name); // Outputs "Alice" and "Charlie"
}

You want to count/ size of Collection: The ICollection interface includes a Count property, which provides a convenient way to determine the number of items in a collection.

1
2

ICollection<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
Console.WriteLine($"Number of items: {numbers.Count}"); // Outputs "Number of items: 5"

You Need to Check Item Existence: TheContains method provided byICollection allows you to determine whether a specific item exists in the collection.

ICollection<string> colors = new List<string> { "Red", "Green", "Blue" };
if (colors.Contains("Green"))
{
    Console.WriteLine("Green is in the collection!");
}

Building Custom Collections: When developing a custom collection type, implementing the ICollection interface is beneficial as it standardizes the basic operations such as add, remove, and count, utilizing generics for flexibility and type safety.

public class CustomCollection<T> : ICollection<T>
{
  private List<T> _items = new List<T>();

  public int Count => _items.Count;
  public bool IsReadOnly => false;

  public void Add(T item) => _items.Add(item);
  public void Clear() => _items.Clear();
  public bool Contains(T item) => _items.Contains(item);
  public void CopyTo(T[] array, int arrayIndex) => _items.CopyTo(array, arrayIndex);
  public bool Remove(T item) => _items.Remove(item);

  public IEnumerator<T> GetEnumerator() => _items.GetEnumerator();
  IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

In the example above, ‘ T ’ could represent any class object.

Working with Intermediate-Level Collections: ICollection is commonly used in intermediate-level collections that need both enumeration and modification capabilities, such as List<T> and HashSet<T>.

using System;
using System.Collections.Generic;

class Program
{
  static void Main()
  {
    // Using ICollection with a List<T>
    ICollection<int> numbersList = new List<int> { 1, 2, 3 };
    ModifyCollection(numbersList);

    // Using ICollection with a HashSet<T>
    ICollection<int> numbersSet = new HashSet<int> { 10, 20, 30 };
    ModifyCollection(numbersSet);
  }

  static void ModifyCollection(ICollection<int> collection)
  {
    Console.WriteLine("Before modification:");
    foreach (var item in collection)
    {
      Console.WriteLine(item);
    }

    // Add and remove elements
    collection.Add(100);
    collection.Remove(2);

    Console.WriteLine("After modification:");
    foreach (var item in collection)
    {
      Console.WriteLine(item);
    }

    Console.WriteLine();
  }
}

You Need Thread-Safe Operations: The ICollection interface offers properties such as IsSynchronized and SyncRoot, which aid in the implementation of thread-safe operations. These are especially beneficial in the context of multi-threaded applications.

ICollection collection = new ArrayList();
lock (collection.SyncRoot)
{
  collection.Add(1);
  collection.Add(2);
}

Best Practices for IEnumerable and ICollection

Here are a few tips for using these interfaces effectively:

Use IEnumerable for Read-Only Data: If you’re just reading the data and not changing it, go with IEnumerable .
ICollection for Modifications: If you need to add, remove, or count items, ICollection gives you that flexibility.
Keep Performance in Mind: When working with large datasets, IEnumerable’s lazy evaluation can improve performance by saving memory.
Know Your Collection Type: Whether you’re using IEnumerable or ICollection, pick the right data structure for your needs, like List, Dictionary, or HashSet.
Consider Readability and Maintenance: Ensure the choice between IEnumerable and ICollection improves code readability and aligns with its purpose.
Use LINQ with IEnumerable, Not ICollection: LINQ is optimized for IEnumerable but can still be used with ICollection indirectly.
When Need to Use Single Pass: Once you enumerate an IEnumerable, you can’t re-enumerate it without retrieving it again.

Conclusion

Understanding the differences between IEnumerable and ICollection is essential when working with collections in C#. While IEnumerable is ideal for simple, memory-efficient iteration, ICollection provides additional control and flexibility for modifying collections. Choosing the appropriate interface can result in cleaner, more efficient, and maintainable code.

Join Us & Grow Your Business

Create high-end software solutions for
your company withMoltech Solutions

Moltech Solutions Inc.

Jun, 14th 20255 min read

Services

Web App Development

Success in today's connected, fast-paced digital market depends on web applications. We create secure, scalable, and robust web apps tailored specifically for your business needs.

Understanding IEnumerable vs. ICollection in .NET

Recent Blogs

Simplifying Software Development with Interfaces in C#

Threads or Tasks? The Parallel Programming in C#

Middleware in .NET: Enhancing Request Handling with Custom Logic