Ienumerable And Ienumerator In C# Complete Guide

Complete Examples, Step by Step for Beginners: IEnumerable and IEnumerator in C#

Step 1: What are IEnumerable and IEnumerator?

• IEnumerable: This is an interface that exposes an enumerator, which supports a simple iteration over a non-generic collection or a generic collection. It defines one method: GetEnumerator().

• IEnumerator: This is an interface that enables a simple iteration over a non-generic collection or a generic collection. It includes the following properties and methods:

  • Current: Gets the current element in the collection.
  • MoveNext(): Advances the enumerator to the next element of the collection.
  • Reset(): Sets the enumerator to its initial position, which is before the first element in the collection.

In C#, most collection types (like List<T>, Array, Dictionary<TKey, TValue>) implement IEnumerable (or the generic IEnumerable<T>).

Step 2: Implementing IEnumerable for a Custom Collection

Let's create a simple custom collection that implements IEnumerable to understand how it works.

using System;
using System.Collections;

public class MyCollection : IEnumerable
{
    private string[] _items = { "Apple", "Banana", "Cherry" };

    public IEnumerator GetEnumerator()
    {
        for (int i = 0; i < _items.Length; i++)
        {
            yield return _items[i];
        }
    }
}

class Program
{
    static void Main()
    {
        MyCollection myCollection = new MyCollection();

        foreach (var item in myCollection)
        {
            Console.WriteLine(item);
        }
    }
}

Explanation:

1. We create a class MyCollection that implements the IEnumerable interface.
2. The GetEnumerator() method is overridden to return an IEnumerator. Inside this method, we use yield return to iterate over items in the collection. yield return simplifies the syntax for creating custom iterators.
3. In the Main method, we create an instance of MyCollection and use a foreach loop to iterate through the items.

Step 3: Implementing IEnumerator for a Custom Collection

Now, let's manually implement IEnumerator without using yield return to understand how it works behind the scenes.

using System;
using System.Collections;

public class MyCollection : IEnumerable
{
    private string[] _items = { "Apple", "Banana", "Cherry" };

    public IEnumerator GetEnumerator()
    {
        return new MyCollectionEnumerator(_items);
    }
}

public class MyCollectionEnumerator : IEnumerator
{
    private string[] _items;
    private int _index = -1;

    public MyCollectionEnumerator(string[] items)
    {
        _items = items;
    }

    public object Current
    {
        get
        {
            if (_index == -1)
                throw new InvalidOperationException("Enumeration has not started.");
            if (_index >= _items.Length)
                throw new InvalidOperationException("Enumeration has finished.");

            return _items[_index];
        }
    }

    public bool MoveNext()
    {
        _index++;
        return (_index < _items.Length);
    }

    public void Reset()
    {
        _index = -1;
    }
}

class Program
{
    static void Main()
    {
        MyCollection myCollection = new MyCollection();

        foreach (var item in myCollection)
        {
            Console.WriteLine(item);
        }
    }
}

Explanation:

1. We create a custom enumerator class MyCollectionEnumerator that implements IEnumerator.
2. Inside the MyCollectionEnumerator class:
   • The constructor receives an array of items and initializes the _index property.
   • The Current property returns the current item based on the _index. If _index is out of bounds, it throws an InvalidOperationException.
   • The MoveNext() method advances the _index and returns true if there are more items to iterate over.
   • The Reset() method sets the _index back to -1.
3. In MyCollection.GetEnumerator(), we return an instance of MyCollectionEnumerator initialized with the items.
4. The foreach loop in the Main method works as usual, but now it uses our custom enumerator.

Step 4: Using Generic Versions (IEnumerable and IEnumerator)

Using the generic versions of IEnumerable<T> and IEnumerator<T> is preferred because they provide type safety and eliminate the need for casting.

Here's how you can modify the previous example to use generics.

using System;
using System.Collections;
using System.Collections.Generic;

public class MyCollection : IEnumerable<string>
{
    private string[] _items = { "Apple", "Banana", "Cherry" };

    public IEnumerator<string> GetEnumerator()
    {
        return new MyCollectionEnumerator(_items);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class MyCollectionEnumerator : IEnumerator<string>
{
    private string[] _items;
    private int _index = -1;

    public MyCollectionEnumerator(string[] items)
    {
        _items = items;
    }

    public string Current
    {
        get
        {
            if (_index == -1)
                throw new InvalidOperationException("Enumeration has not started.");
            if (_index >= _items.Length)
                throw new InvalidOperationException("Enumeration has finished.");

            return _items[_index];
        }
    }

    object IEnumerator.Current => Current;

    public bool MoveNext()
    {
        _index++;
        return (_index < _items.Length);
    }

    public void Reset()
    {
        _index = -1;
    }

    public void Dispose()
    {
        // Typically, you would release resources here.
        // In this simple example, it is not necessary.
    }
}

class Program
{
    static void Main()
    {
        MyCollection myCollection = new MyCollection();

        foreach (var item in myCollection)
        {
            Console.WriteLine(item);
        }
    }
}

Explanation:

1. We change MyCollection to implement IEnumerable<string> instead of IEnumerable.
2. GetEnumerator() now returns an IEnumerator<string>.
3. We add an implicit implementation of the non-generic GetEnumerator() to satisfy the IEnumerable requirement.
4. MyCollectionEnumerator implements IEnumerator<string> instead of IEnumerator.
5. The Current property is now strongly typed to string.
6. We add an explicit implementation of the non-generic Current property to satisfy the IEnumerator requirement.
7. The Dispose() method is also implemented but does not perform any action in this simple example.