In this article we will try to bring some light on Enumerator or foreach. What is Better? Both has same motive, to perform loop. One allow us to have more control over looping and other provide simple syntax. This also brings light on very familiar concept of foreach loop. Exactly how foreach loop works and what is internal processing. Lets first dig into enumerator.

Enumerator or foreach

Enumerator

IEnumerator is used to go through a list with significant control. It has one object type property, i.e., Current which has getter only and two methods,

• MoveNext that returns boolean
• Reset

Code sample

IEnumerator enumerator = enumerable.GetEnumerator();  

while (enumerator.MoveNext())  
{  
    object element = enumerator.Current;  
    // Perform your logic logic on the element  
}

Let’s consider a scenario where you have to loop through a collection in two different method take the example above,

List<int> enumerable = new List<int>();  

for (int i = 0; i <= 20; i++)  
{  
   enumerable.Add(i);  
}  

IEnumerator enumerator = enumerable.GetEnumerator();  
Console.WriteLine("FirstLoopMethod start...");  

while (enumerator.MoveNext())  
{  
    object element = enumerator.Current;  
    int num = int(element);  
    Console.WriteLine(num);  
    if(num > 10)  
    {  
       SecondLoopMethod(enumerator);  
    }  

    // you logic here  
    // Perform your logic on the element  
}  

private void SecondLoopMethod(IEnumerator enumerator)  
{  
    Console.WriteLine();  
    Console.WriteLine("SecondLoopMethod start...");  
    while (enumerator.MoveNext())  
    {  
       object element = enumerator.Current;  
      int num = int(element);  
      Console.WriteLine(num);  

      // Perform your logic logic on the element  
   }  
}

This is the output you get,

Here you can see in the SecondLoopMethod the iteration started from where we left it in the first method.

That’s the benefit and control of using IEnumerator.

Where if we try to this with IEnumerable then in the second method it again starts looping from the beginning

Here is the documentation on Enumerator.

Enumerable / foreach

We can loop through items of the list using IEnumerator too. IEnumerable and IEnumerator are both interfaces in the .net framework.

IEnumerable has just one method declaration i.e. GetEnumerator which return an enumerator.

Every object which can be looped through using foreach, inherits from IEnumerable directly or indirectly.

You cannot use foreach on classes which do not inherit from IEnumerable

If you have a model and want to loop through its array using foreach then that class must inherit from IEnumerable

Code sample

foreach(object item in enumerable)  
{  
    // Your logic on the item  
}

When your code executes the above code becomes.

While debugging the code I found following things

• When debugger was at `enumerable` in above foreach loop the debugger move to GetEnumerator() method in class 
• When debugger was at in keyword in loop MoveNext method of Enumerator class was called
• When debugger was at item it loaded the object in it 

IEnumerator enumerator = enumerable.GetEnumerator();  

while (enumerator.MoveNext())  
{  
    object item = enumerator.Current;  
    // Perform logic on the item  
}

Documentation for Enumerable.

Now what are the benefits and drawbacks of both?

IEnumerable simplifies and shortens the original looping syntax compared to IEnumerator
IEnumerator provides better flexibility and control over your looping logic

Cheers!

More posts like this

• Introduction to Azure Cosmos DB
• Enhancing app security with Azure Managed Identities
• IL code performance of Generic List And Non Generic List
• How does a dictionary maintains data
• What is better between Enumerator or foreach