Real time example of IEnumerable and IEnumerator in C#

To better understand we will create a list of age

List<int> ages = new List<int>();
ages.Add(10);
ages.Add(20);
ages.Add(30);
ages.Add(40);
ages.Add(50);

Now convert this list to IEnumerable

IEnumerable<int> age_IEnumerable = (IEnumerable<int>)ages;
foreach (int age in age_IEnumerable)
{
    Console.WriteLine(age);
}

There is nothing new, we used foreach here very straight forward, now let’s convert the ages into IEnumerator, there is a method GetEnumerator to convert a list into IEnumerator

IEnumerator<int> age_IEnumerator = ages.GetEnumerator();
while (age_IEnumerator.MoveNext())
{
    Console.WriteLine(age_IEnumerator.Current);
}

As you can see here we used while rather than foreach because foreach cannot be used with IEnumerator, but still there is nothing which can suggest us when should we use IEnumerable and where to IEnumerator.

Before we go further, we should know, IEnumerable uses IEnumerator internally also have a function GetEnumerator to convert into IEnumerator, we should use IEnumerable because it make coding easier and clearer as we can see in above example.

Now let’s discuss the main difference, IEnumerable doesn’t remember the state, which row or record it is iterating while IEnumerator remember it and we are going to see this with example by creating method PrintUpto30 and PrintGreaterThan30

Let’s first check with IEnumerator

public void PrintAgeUpto30(IEnumerator<int> age_IEnumerator)
{
   while (age_IEnumerator.MoveNext()){
      Console.WriteLine(age_IEnumerator.Current);
      if (age_IEnumerator.Current > 20) {
         Console.WriteLine("PrintGreaterThan30 is called");
         PrintGreaterThan30(age_IEnumerator);
      }
   }
}


public void PrintGreaterThan30(IEnumerator<int> age_IEnumerator)
{
    while (age_IEnumerator.MoveNext())
        Console.WriteLine(age_IEnumerator.Current);
}
// Now Call PrintUpto30 which will call PrintGreaterThan30 
// by using our previous age IEnumerator
PrintUpto30(IEnumerator);

As we know IEnumerator persists state so once we will call PrintGreaterThan30 by passing age_IEnumerator it will print the remaining list, here is the output:

10
20
30
PrintGreaterThan30 is called
40
50

Now let’s check same code with IEnumerable

public void PrintUpto30(IEnumerable<int> age_IEnumerable)
{
    foreach (int age in age_IEnumerable){
       Console.WriteLine(age);
       if (age > 20){
         Console.WriteLine("PrintGreaterThan30 is called");
        PrintGreaterThan30(age_IEnumerable);
      }
   }
}


public void PrintGreaterThan30(IEnumerable<int> age_IEnumerable)
{
  foreach (int age in age_IEnumerable)
    Console.WriteLine(age);
}

// Now Call PrintUpto30 by using our variable age_IEnumerable

PrintAgeUpto30(age_IEnumerable);

Now check the output you will see “PrintGreaterThan30 is called” many times something like this

10
20
30
PrintGreaterThan30 is called
10
....
50
40
PrintGreaterThan30 is called
10
...
50
50
PrintGreaterThan30 is called
10
50

Conclusion:

1. Both are interface
2. IEnumerable code are clear and can be used in foreach loop
3. IEnumerator use While, MoveNext, current to get current record
4. IEnumerable doesn’t remember state
5. IEnumerator persists state means which row it is reading
6. IEnumerator cannot be used in foreach loop
7. IEnumerable defines one method GetEnumerator which returns an IEnumerator
8. IEnumerator allows readonly access to a collection