Working with Enumerable Collections in .NET

In .NET, the IEnumerable<T> interface represents a sequence of values that can be enumerated. It is commonly used to define collections that can be iterated over using a foreach loop or LINQ queries. However, unlike other collection interfaces such as ICollection<T> or IList<T>, IEnumerable<T> does not provide methods for adding or removing items from the collection.

This tutorial will explore how to work with IEnumerable<T> collections in .NET, including how to add new items to an existing collection and create new collections by combining multiple sequences of values.

Understanding IEnumerable

The IEnumerable<T> interface is defined as follows:

public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

As you can see, the interface only provides a single method, GetEnumerator, which returns an enumerator that can be used to iterate over the sequence of values.

Creating New Collections

One common scenario when working with IEnumerable<T> collections is creating new collections by combining multiple sequences of values. This can be achieved using the Concat method provided by the Enumerable class:

var items = new[] { 1, 2, 3 };
var newItems = new[] { 4, 5, 6 };

var combinedItems = items.Concat(newItems);

In this example, the combinedItems variable will contain a new sequence that includes all the values from both items and newItems.

Adding New Items to an Existing Collection

If you need to add new items to an existing IEnumerable<T> collection, you can use the Concat method again:

var items = new[] { 1, 2, 3 };
var newItem = 4;

var updatedItems = items.Concat(new[] { newItem });

In this example, the updatedItems variable will contain a new sequence that includes all the values from items, plus the new item.

Alternatively, you can use the Append method provided by .NET Core:

var items = new[] { 1, 2, 3 };
var newItem = 4;

var updatedItems = items.Append(newItem);

Note that in both cases, a new sequence is created, and the original collection remains unchanged.

Implementing Custom Extension Methods

If you need more flexibility when working with IEnumerable<T> collections, you can implement custom extension methods. For example:

public static class EnumerableExtensions
{
    public static IEnumerable<T> Add<T>(this IEnumerable<T> source, T item)
    {
        foreach (var current in source)
        {
            yield return current;
        }
        yield return item;
    }

    public static IEnumerable<T> Prepend<T>(this IEnumerable<T> source, T item)
    {
        yield return item;
        foreach (var current in source)
        {
            yield return current;
        }
    }
}

These extension methods can be used to add new items to an existing collection or prepend items to the beginning of a sequence.

Best Practices

When working with IEnumerable<T> collections, keep the following best practices in mind:

• Use Concat or Append to create new collections by combining multiple sequences of values.
• Avoid modifying the original collection; instead, create a new sequence that includes the updated values.
• Implement custom extension methods if you need more flexibility when working with IEnumerable<T> collections.

By following these guidelines and using the techniques described in this tutorial, you can effectively work with IEnumerable<T> collections in .NET and write efficient, readable code.