Iterating an IEnumerable. Best way?

Question

Looking to the implementation of the method

void InsertRange(int index, IEnumerable<T> collection)

in the List<> class (.NET Framework 4.5.2), I can see an iteration over a collection like this

using(IEnumerator<T> en = collection.GetEnumerator()) {
    while(en.MoveNext()) {
        Insert(index++, en.Current);                                    
    }                
}

I am wondering what could be the reason to prefer that syntax over this one

foreach(var item in collection)
{
    Insert(index++, item)
}

I have created an assembly with two methods each one using a different approach. Then, looking into the generated IL code, I can see both methods calling the Dispose method enforced by the implementation of the IEnumerator<T> and hence IDisposable.

So IDisposable is not the reason and here is my question.

Is there any reason to prefer one syntax vs the other, other than simple style(ish) preferences?

foreach basically behind the scenes enumerate the way you are seeing implementation, — Ehsan Sajjad, Jul 20 '15 at 16:29

score 5 · Accepted Answer · edited Jul 20 '15 at 16:42

5

foreach is the recommended way because you don't specify details about how you want to iterate over the enumeration. Also, you write less code and it's more readable.

edited Jul 20 '15 at 16:42

Ehsan Sajjad

61,834
16
105
160

answered Jul 20 '15 at 16:19

Francisco Goldenstein

13,299
7
58
74

I wonder why the .NET Framework Team did not use foreach in that implementation, though – Juan M. Elosegui Jul 20 '15 at 16:39
the reason for it is that `IEnumerable` should not have side effects. – Daniel A. White Jul 20 '15 at 16:56
@jmelosegui http://stackoverflow.com/questions/101265/why-is-there-not-a-foreach-extension-method-on-the-ienumerable-interface – Daniel A. White Jul 20 '15 at 16:57

w.b · Answer 2 · 2015-07-20T16:26:01.310

3

They're exactly equivalent, it's something called syntactic sugar. The only reason to use foreach is because it's shorter, less error prone, more readable etc.

You can chceck the article on foreach implementation on MSDN.

edited Jul 20 '15 at 16:26

answered Jul 20 '15 at 16:20

w.b

11,026
5
30
49

score 0 · Answer 3 · answered Jul 20 '15 at 16:26

0

for loops are faster than foreach loops. The difference is tiny now though, so it's usually not even worth considering. I think there was a bigger difference in earlier versions of .net.

answered Jul 20 '15 at 16:26

Peter Dongan

1,762
12
17

Ehsan Sajjad · Answer 4 · 2015-07-20T16:44:36.363

Any collection which inherits from IEnumerable<T> (an enumerable object) it can be enumerated using foreach loop.

Consider this example:

foreach(char c in "Ehsan")
{
    Console.WriteLine(c);
}

It is bascially a high level way of iterating the IEnumerable<T> , if the enumerator implements iDisposable the foreach statement uses using statement and it implilctly will dispose the enumerator object.

At low level we can wrtie it :

using(var enumerator = "Ehsan".GetEnumerator())
{
    while(enumerator.MoveNext())
    {
       var element = enumerator.Current;
       Console.WriteLine(element);
    }

}

So the foreach is doing the work for you, you don't have to write like the above to enumerate the IEnumeable<T>

Iterating an IEnumerable. Best way?

4 Answers4