How do foreach loops work in C#?

Question

I don't understand which types of classes can use foreach loops. Please help!

Answer 1

Just call foreach loops on any classes that implement the IEnumerable and IEnumerator classes...

ie:

public MYClass : IEnumerator, IEnumerable { 
    /*implement the interfaces */ 
}

Answer 2

From MSDN:

The foreach statement repeats a group of embedded statements for each element in an array or an object collection. The foreach statement is used to iterate through the collection to get the desired information, but should not be used to change the contents of the collection to avoid unpredictable side effects. (emphasis mine)

So, if you have an array, you could use the foreach statement to iterate through the array, like so:

 int[] fibarray = new int[] { 0, 1, 2, 3, 5, 8, 13 };
    foreach (int i in fibarray)
    {
        System.Console.WriteLine(i);
    }

You could also use it to iterate through a List<T> collection, like so:

List<string> list = new List<string>();

foreach (string item in list)
{
    Console.WriteLine(item);
}

Answer 3

Actually, strictly speaking, all you need to use foreach is a public GetEnumerator() method that returns something with a bool MoveNext() method and a ? Current {get;} property. However, the most common meaning of this is "something that implements IEnumerable/IEnumerable<T>, returning an IEnumerator/IEnumerator<T>.

By implication, this includes anything that implements ICollection/ICollection<T>, such as anything like Collection<T>, List<T>, arrays (T[]), etc. So any standard "collection of data" will generally support foreach.

For proof of the first point, the following works just fine:

using System;
class Foo {
    public int Current { get; private set; }
    private int step;
    public bool MoveNext() {
        if (step >= 5) return false;
        Current = step++;
        return true;
    }
}
class Bar {
    public Foo GetEnumerator() { return new Foo(); }
}
static class Program {
    static void Main() {
        Bar bar = new Bar();
        foreach (int item in bar) {
            Console.WriteLine(item);
        }
    }
}

How does it work?

A foreach loop like foreach(int i in obj) {...} kinda equates to:

var tmp = obj.GetEnumerator();
int i;
while(tmp.MoveNext()) {
    i = tmp.Current;
    {...} // your code
}

However, there are variations. For example, it the enumerator (tmp) supports IDisposable, it is used too (similar to using).

Note that the positioning of "int i" outside the loop is important if you use i in an anonymous method/lambda inside your code-block. But that is another story ;-p

Answer 4

According to this post (http://blogs.msdn.com/kcwalina/archive/2007/07/18/DuckNotation.aspx) duck typing is used.

Answer 5

Here's the docs: Main article With Arrays With Collection Objects

It's important to note that "The type of the collection element must be convertible to the identifier type". This sometimes cannot be checked at compile time and can generate a runtime exception if the instance type is not assignable to the reference type.

This will generate a runtime exception if there is an non-Apple in the fruit basket, such as an orange.

List<Fruit> fruitBasket = new List<Fruit>() { new Apple(), new Orange() };
foreach(Apple a in fruitBasket)

This safely filters the list to only the Apples using Enumerable.OfType

foreach(Apple a in fruitBasket.OfType<Apple>() )

Answer 6

I think the best answer given by "Marc Gravell" but I want to add some notes: do not change your IEnumerable object inside the foreach do not change your Iterator object inside the foreach avoid foreach on the collections that are being used by different threads except you are handling this matter