foreach is a loop or iterator? Or can it be both?

Question

In a video tutorial the instructor stated not to fall for the nonsense of thinking that the foreach is a loop, and it was vehement that he was an iterator.

There are cases where we can go through the items of an array using foreach as a "compact for version".

That is, when we use foreach for arrays or matrices, in the background we are using it as a compact version of loop for. When we use it to iterate collections, it is in fact a TRUE iterator because "access" the methods of the Ienumerator

Is the statement correct? Can anyone add anything about it?

Follow example code:

//foreach com Arrays
    int[] array = new int[]{1, 2, 3, 4, 5, 6};
    foreach (int item in array) 
    {
      Console.WriteLine(item);
    }

However, the C# compiler generates C# code equivalent to the generated CIL:

//Código C# equivalente ao CIL gerado
    int[] tempArray;
    int[] array = new int[]{1, 2, 3, 4, 5, 6};
    tempArray = array;
     for (int counter = 0; (counter < tempArray.Length); counter++) {
       int item = tempArray[counter];
       Console.WriteLine(item);
    }

The code above was taken from the book: Essential C-6.0, 5th Edition [ Author Mark Michaelis ] page 582

Answer 1

In general video lessons are made by people who barely understand the language, let alone programming languages. I won’t talk about specific case, but always keep this in mind. There are even good things, usually in English and are paid, as the Pluralsight.

All that runs directly in repetition is a loop, or loop in English. So both are loops yes.

If the intention was to say foreach does not do the traditional process that is usually done in a for, is also wrong.

The foreach is a mechanism to iterate with a data collection. How this is done depends on a few factors. The most common way is to use an iterator provided by the collection, but it is possible to use the same algorithm as the for in cases such as the array and string. Although it does not exist, nothing prevents in the future having other mechanisms or other objects that iterate without a ready iterator.

Let’s look at the code using the two forms:

using static System.Console;
using System.Collections.Generic;
public class C {
    public static void Main() {
        int[] array = new int[]{1, 2, 3, 4, 5, 6};
        foreach (int item in array) WriteLine(item);
        var lista = new List<int>{1, 2, 3, 4, 5, 6};
        foreach (int item in lista) WriteLine(item);
        var texto = "123456";
        foreach (char item in texto) WriteLine(item);
    }
}

Behold working in the ideone. And in the .NET Fiddle. And see decompiled in Sharplab. Also put on the Github for future reference.

Of course, the way the decompiler will govern the source depends on its quality, but it is clear that in the case of array turns into something without iterator provided by it, just as string, and with a list a ready iterator is used, so it can rebuild itself foreach. But the foreach with iterator actually is equivalent to this code:

IEnumerator<int> enumerator = lista.GetEnumerator();
try {
    while (enumerator.MoveNext()) {
        int item = enumerator.Current;
        WriteLine(item);
    }
} finally {
    IDisposable disposable = enumerator as IDisposable;
    if (disposable != null) disposable.Dispose();
}

So it’s a loop also.

Note that even the for uses an iterator, but it’s a manual that the programmer controls as he wants.

See what it is iteration.

Answer 2

As stated in @Maniero’s reply, foreach is a loop because it runs a block of code repeatedly, in a nonrecursive way, such as the while, for or do-while, or even goto in some scenarios.

I don’t know what the tutor wanted to explain, but if I were the tutor I would explain that the foreach is a simplified way to use a IEnumerable<T>.

As you can see IEnumerable<T> has only one method IEnumerator<T> GetEnumerator(). If the foreach did not exist would have to write a code similar to this to traverse the elements:

IEnumerable<string> values = new[]{"olá"};
var it = values.GetEnumerator();
while(it.MoveNext()){
    Console.WriteLine(it.Current);
}

The foreach then allows you to have a simpler code. In fact whenever you use the foreach It actually generates a code similar to the one I showed you.

But the story does not end here. If you pay attention you see that the IEnumerator<T> also implements the interface IDisposable. And in reality when you use the foreach the platform also generates code to call the Dispose.

In other words, there’s something missing from the code I showed you earlier:

IEnumerable<string> values = new[]{"olá"};
var it = values.GetEnumerator();
using(it){
    while(it.MoveNext()){
        Console.WriteLine(it.Current);
    }
}

Now you have a general idea of how foreach works. The code generated by .NET should not be very different from.

Note - The platform. NET is evolving and it is normal that they have found a way to generate more efficient code depending on the data structure being used. It seems that according to the book quoted by the questioner, they found a way to optimize the code generated to traverse any array, or even any IList

Answer 3

Hello, I found this discussion a little bit interesting, and just to complement what @Brunocosta and @Maniero said, note that the following code below also works normally:

IEnumerable<string> itens = new string[1] { "meu texto" };

for (IEnumerator<string> it = itens.GetEnumerator(); it.MoveNext();)
{
    Console.WriteLine(it.Current);
}

Note that here I also gave up the syntax sugar proposed by foreach using the for, being possible to iterate with a collection IEnumerable<string>.

Note: The above code is solely intended to discipline, in order to show that both foreach have the characteristics of a loop, as well as to iterate collections. I do not recommend using this approach, precisely because we have the own foreach to do so.