Exploring Collections in C#

3 min readMar 20, 2024

Collections are integral to programming, facilitating the storage and manipulation of data. In C#, the IEnumerable family provides a range of interfaces and classes for working with collections flexibly and efficiently. In this detailed blog, we’ll delve into the IEnumerable family, covering its history, generics, and various implementations, including Lists and Iterators. We’ll provide code snippets for each step to illustrate the concepts effectively.

Embark on a journey of continuous learning and exploration with DotNet-FullStack-Dev. Uncover more by visiting our https://dotnet-fullstack-dev.blogspot.com reach out for further information.

History of Collection Implementations in C#

Arrays (Pre-Collection Era)

Before the introduction of the IEnumerable family, arrays were the primary way to store collections of elements in C#. While arrays offer fixed-size storage, they lack dynamic resizing capabilities.

int[] array = new int[5];
array[0] = 1;
array[1] = 2;
// ...

ArrayList (Classic Collection)

The ArrayList class was introduced in .NET Framework 1.1 as part of the System.Collections namespace. It provided a dynamically resizable array-like data structure.

ArrayList arrayList = new ArrayList();
arrayList.Add(1);
arrayList.Add("two");
// ...

List<T> (Generic Collection)

With the advent of generics in .NET Framework 2.0, the List<T> class was introduced. It offers type safety, better performance, and improved code readability compared to ArrayList.

List<int> list = new List<int>();
list.Add(1);
list.Add(2);
// ...

Generics in IEnumerable Family

Generics allow developers to create reusable components that work with any data type. The IEnumerable family utilizes generics to provide type-safe collections.

Declaring and Using Generic List

List<string> strings = new List<string>();
strings.Add("Hello");
strings.Add("World");
// ...

Benefits of Generics

Type Safety: Ensures that only objects of the specified type can be added to the collection.
Performance: Eliminates the need for boxing and unboxing operations, leading to better performance.
Code Readability: Enhances code readability by specifying the type of objects stored in the collection.

IEnumerable Family Implementations

Apart from List<T>, the .NET framework offers several other collection-like data structures catering to specific use cases and requirements.

LinkedList<T>

The LinkedList<T> class provides a doubly linked list implementation, offering efficient insertion and removal operations at the cost of random access performance.

LinkedList<int> linkedList = new LinkedList<int>();
linkedList.AddLast(1);
linkedList.AddLast(2);
// ...

ObservableCollection<T>

The ObservableCollection<T> class, part of the System.Collections.ObjectModel namespace, provides a dynamic data collection that implements INotifyCollectionChanged for data binding scenarios.

ObservableCollection<string> collection = new ObservableCollection<string>();
collection.Add("Item 1");
collection.Add("Item 2");
// ...

IEnumerable<T> and Iterators

The IEnumerable<T> interface and iterators allow for easy iteration over collections, providing a simple and efficient way to process elements.

public IEnumerable<int> GetNumbers()
{
    for (int i = 1; i <= 5; i++)
    {
        yield return i;
    }
}

Conclusion

The IEnumerable family in C# offers a wide range of options for working with collections, catering to various requirements and use cases. From the classic ArrayList to the modern List<T> and specialized implementations like LinkedList<T> and ObservableCollection<T>, developers have a plethora of options to choose from based on their specific needs. With the power of generics and iterators, these collection implementations provide type safety, performance, and flexibility, making them indispensable tools in C# programming.

Understanding the history and features of the IEnumerable family empowers developers to make informed decisions when selecting the appropriate data structure for their applications.

Happy coding!