The advantage of a foreach loop over a forloop is the fact that it is unnecessary to know the number of itemswithin the collection when an iteration starts. This avoids iteratingoff the end of the collection using an index that is not available. AsBill Wagner pointed out in his Custom Iterators article last week, aforeach loop also allows code to iterate over a collection withoutfirst loading the collection in entirety into memory. In this article Iam going to explore how the foreach statement works under the covers.This sets the stage for a follow on discussion of how the yieldstatement works.

foreach with Arrays

Consider the foreach code listing shown in Listing 1:

Listing 1: foreach with Arrays

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

From this code, the C# compiler creates CIL equivalent of a for loop like this (Listing 2):

Listing 2: Compiled Implementation of foreach with Arrays

int[] tempArray;
int[] array = new int[]{1, 2, 3, 4, 5, 6};
tempArray = array;
for (int counter=0; (counter < tempArray.Length); counter++)
{
readonly int item = tempArray[counter];
Console.WriteLine(item);
}

Since the collection is an array and indexingthe array is fast, the foreach loop implementation relies on supportfor the Length property and the index operator ([]). However, these twoarray features are not available on all collections. Many collectionsdo not have a known number of elements and many collection classes donot support retrieving elements by index.

foreach with IEnumerable<T>

To address this, the foreach loop uses the System.Collections.Generic.IEnumerator<t>.(Given C# 2.0.s generics support, there is very little reason toconsider using the non-generic equivalent collections so I will ignorethem from this discussion except to say their behavior is almostidentical.) IEnumerator<t> is designed to enable the iterator patternfor iterating over collections of elements, rather than thelength-index pattern shown in earlier. IEnumerator<t> includes threemembers. The first is bool MoveNext(). Using this method, we can movefrom one element within the collection to the next while at the sametime detecting when we have enumerated through every item using theBoolean return. The second member, a read-only property called Current,returns the element currently in process. With these two members on thecollection class, it is possible to iterate over the collection simplyusing a while loop as demonstrated in the code listing below (Listing3): </t></t></t>

Listing 3: Iterating over a collection using while

System.Collections.Generic.Stack<int> stack =
new System.Collections.Generic.Stack<int>();
int number;
// …
// This code is conceptual, not that the actual code.
while(stack.MoveNext())
{
number = stack.Current;
Console.WriteLine(number);
}
</int></int>

The MoveNext() method in this listing returnsfalse when it moves past the end of the collection. This replaces theneed to count elements while looping. (The last member on IEnumerator<t>,Reset(), will reset the enumeration.) This while listing shows the gistof the C# compiler output, but it doesn.t actually work this waybecause it omits two important details about the actual implementation:interleaving and error handling. </t>

Interleaving

The problem with is that if there are two (ormore) interleaving loops over the same collection, one foreach insideanother, then the collection must maintain a state indicator of thecurrent element so that when MoveNext() is called, the next element canbe determined. The problem is that one interleaving loop can affect theother. (The same is true of loops executed by multiple threads.)

Figure 1: IEnumerable class diagram

To overcome this problem, the IEnumerator<t>interfaces are not supported by the collection classes directly. Asshown in Figure 1, there is a second interface called IEnumerable<t> whose only method is GetEnumerator(). The purpose of this method is to return an object that supports IEnumerator<t>.Rather than the collection class maintaining the state itself, adifferent class, usually a nested class so that it has access to theinternals of the collection, will support the IEnumerator<t> interfaceand keep the state of the iteration loop. Using this pattern, the C#equivalent of a foreach loop will look like what's shown in Listing 4. </t></t></t></t>

Listing 4: A separate enumerator maintains state during an iteration

System.Collections.Generic.Stack<int> stack =
new System.Collections.Generic.Stack<int>();
int number;
System.Collections.Generic.Stack<int>.IEnumerator<int> enumerator;

// …
// If IEnumerable<t> is implemented explicitly,
// then a cast is required.
// ((IEnumerable)stack).GetEnumeraor();
enumerator = stack.GetEnumerator();
while (enumerator.MoveNext())
{
number = enumerator.Current;
Console.WriteLine(number);
}
</t></int></int></int></int>

Error Handling

Since the classes that implement the IEnumerator<t>interface maintain the state, there are occasions when the state needscleaning up after all iterations have completed. To achieve this, theIEnumerator<t> interface derives from IDisposable. Enumerators thatimplement IEnumerator do not necessarily implement IDisposable, but ifthey do, Dispose() will be called as well. This enables the calling ofDispose() after the foreach loop exits. The C# equivalent of the finalCIL code, therefore, looks like Listing 5.
Listing 5: Compiled Result of foreach on Collections </t></t>

System.Collections.Generic.Stack<int> stack =
new System.Collections.Generic.Stack<int>();
int number;
System.Collections.Generic.Stack<int>.Enumerator<int> enumerator;
IDisposable disposable;
enumerator = stack.GetEnumerator();

try
{
while (enumerator.MoveNext())
{
number = enumerator.Current;
Console.WriteLine(number);
}
}
finally
{
// Explicit cast used for IEnumerator<t>.
disposable = (IDisposable) enumerator;
disposable.Dispose();

// IEnumerator will use the as operator unless IDisposable
// support determinable at compile time.
// disposable = (enumerator as IDisposable);
// if (disposable != null)
// {
// disposable.Dispose();
// }
}
</t></int></int></int></int>

Notice that because the IDisposable interface is supported by I
Enumerat
or<t>, the C# code can be simplified with the using keyword as shown in Listing 6. </t>

Listing 6: Error handling and resource cleanup with using

System.Collections.Generic.Stack<int> stack =
new System.Collections.Generic.Stack<int>();
int number;

using(
System.Collections.Generic.Stack<int>.Enumerator<int> enumerator =
stack.GetEnumerator())
{
while (enumerator.MoveNext())
{
number = enumerator.Current;
Console.WriteLine(number);
}
}
</int></int></int></int>

However, recall that the using keyword is notdirectly supported by CIL either, so in reality the former code is amore accurate C# representation of the foreach CIL code.

Readers may recall that the compiler preventsassignment of the foreach variable identifier (number). As isdemonstrated in Listing 6, an assignment of number would not be achange to the collection element itself so rather than mistakenlyassume that, the C# compiler prevents such an assignment altogether.

In addition, the element count within acollection cannot be modified during the execution of a foreach loop.If, for example, we called stack.Push(42) inside the foreach loop, itwould be ambiguous whether the iterator should ignore or incorporatethe change to stack . should iterator iterate over the newly added itemor ignore it and assume the exact same state as when it wasinstantiated.

Because of this ambiguity, an exception oftype System.InvalidOperationException is thrown if the collection ismodified within a foreach loop, reporting that the collection wasmodified after the enumerator was instantiated.

(This content was largely taken from the Collections chapter of my book, Essential C# 2.0 [Addison-Wesley])

I?ve been implementing numerical librariesin .NET and have come to some conclusions about iteration performance.My classes have to hold a large amount of data and be able to iteratethrough that data as quickly as possible. In order to compare variousmethods, I created a simple class called Data that encapsulates anarray of doubles.

Method #1: Enumeration

Data implements IEnumerable. It contains GetEnumerator which returns its own DataEnumerator, an inner class.

?
public IEnumerator GetEnumerator()
{
return new DataEnumerator( this );
}

internal class DataEnumerator : IEnumerator
{
private Data internal_ = null;
private int index = -1;

public DataEnumerator( Data data )
{
internal_ = data;
}

public object Current
{
get
{
return internal_.Array[index];
}
}

public bool MoveNext()
{
index++;
if ( index >= internal_.Array.Length )
{
return false;
}
return true;
}

public void Reset()
{
index = -1;
}
}
?

Method #2: Indexing

I implemented an index operator on the class which simply calls the index operator on the array.

public double this[int position]
{
get
{
return array_[position];
}
}

Method #3: Indirect Array

I created a property to access the array.

public double[] Array
{
get
{
return array_;
}
}

When iterating, I called the Array property and then its index operator.

d = data.Array[j];

Method #3: Direct Array

I created a reference to the array.

double[] array = data.Array;

Then, I iterate through that reference.

d = array[j];

Method #4: Pointer Math

Finally, I tried improving performance by iterating through the array in Managed C++ using pointer manipulation.

static void iterate( Data& data )
{
double d;
double __pin* ptr = &( data.Array[0] );
for ( int i = 0; i < data.Array.Length; i++ )
{
d = *ptr;
++ptr;
}
}

I called it this way:

Pointer.iterate( data );

Conclusions

To test the different methods, I allocated1,000,000 doubles into an array and indexed over all of them. Irepeated this 1,000 times to minimize randomness. Here are theresults…

Enumeration is always slow. That?s notsurprising as I?m using a general data structure to hold the doubles.Each access performs a cast.The three operator/property methods differed very slightly. These areprobably all optimized similarly.Using pointer math to traverse over the raw data was significantlyfaster. This is probably due to the fact that there?s no boundschecking.In summary, if you have large amounts of data and performance iscritical, consider using managed C++.

Acknowledgements

Thanks to Mark Vulfson of ProWorks for tips on using Flipper Graph Control. Also, to my colleagues Ken Baldwin and Steve Sneller at CenterSpace Software.

To use, open Macro Explorer and copy and pasteinto an existing or new macro project. To run a macro place the cursorat the required insertion point in your document and double-click thename of the macro in Macro Explorer. You may wish to define moreconvenient keyboard shortcuts for each macro via the Tools | Customizemenu.

Imports EnvDTE
Imports System.Diagnostics

Public Module CSharp
' Description: Inserts for loop
Sub ForLoop()
DTE.ActiveDocument.Selection.Text = "for (int i = 0; i < ; i++)"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.LineUp(False, 3)
DTE.ActiveDocument.Selection.CharRight(False, 19)
End Sub

' Description: Inserts while loop
Sub WhileLoop()
DTE.ActiveDocument.Selection.Text = "while ()"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.LineUp(False, 3)
DTE.ActiveDocument.Selection.CharRight(False, 6)
End Sub

' Description: Inserts do-while loop
Sub DoWhileLoop()
DTE.ActiveDocument.Selection.Text = "do"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "} while ();"
DTE.ActiveDocument.Selection.CharLeft(False, 2)
End Sub

' Description: Inserts foreach loop
Sub ForEach()
DTE.ActiveDocument.Selection.Text = "foreach ( in )"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.LineUp(False, 3)
DTE.ActiveDocument.Selection.CharRight(False,
End Sub

'Description: Inserts if block
Sub IfNoElse()
DTE.ActiveDocument.Selection.Text = "if ()"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.LineUp(False, 3)
DTE.ActiveDocument.Selection.CharRight(False, 3)
End Sub

' Description: Inserts if-else block
Sub IfElse()
DTE.ActiveDocument.Selection.Text = "if ()"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "else"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.LineUp(False, 7)
DTE.ActiveDocument.Selection.CharRight(False, 3)
End Sub

' Description: Inserts switch block
Sub Switch()
DTE.ActiveDocument.Selection.Text = "switch ()"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "case :"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "break;"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "case :"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "break;"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "default:"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "break;"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.LineUp(False,
DTE.ActiveDocument.Selection.CharRight(False, 7)
End Sub

' Description: Inserts generic exception block
Sub Exception()
DTE.ActiveDocument.Selection.Text = "try"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "catch (System.Exception ex)"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "{"
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.NewLine()
DTE.ActiveDocument.Selection.Text = "}"
DTE.ActiveDocument.Selection.LineUp(False, 5)
End Sub

End Module

We are going to use "foreach" to iterate through our collection of fruit objects.

Lets assume that we have a class called Fruitwhich contains the fields; string name ,int num and bool ripe. We builda class called Fruits which represents a collection of fruit objects.

public class Fruits
{
//we don?t have to specify private as this is the default modifier
//it?s just included to highlight the fact that this is private to
//the Fruits collection.

private Fruit[] fruitArray;

//Create a basket of fruit

public Fruits()
{
fruitArray = new Fruit[3];
fruitArray[0] = new Fruit("Banana",false,3);
fruitArray[1] = new Fruit("Apples",true,5);
fruitArray[2] = new Fruit("Oranges",true,3);
}
}

In order to obtain each Fruit from the Fruitscollection it would be convenient if the object user could iterate overthe Fruits type using the foreach construct. It would be reasonable tocode:

public class FruitBar
{
public static void Main()
{
Fruits fruitbasket = new Fruits();
//Show only the ripe fruit
foreach (Fruit f in fruitbasket)
{
if (f.ripe == true)
{
Console.WriteLine("Name : {0}",f.name);
Console.WriteLine("Amount : {0}",f.num);
}
{
}
}

Unfortunately attempting to execute this code results in the compiler complaining that it cannot find GetEnumerator.

To use the foreach syntax your class mustsupport the IEnumerable interface found in the System.Collectionsnamespace. IEnumerable defines only one method, public IEnumeratorGetEnumerator(), notice that this method returns another interfaceIEnumerator also found in System.Collections namespace.

IEnumerator supports a simple iteration over a collection. It publishes two methods and a property:

bool MoveNext():
Advances the enumerator tothe next element in the collection. Returns true if successfullyadvanced to the next element in the collection and false if the movewould take it beyond the last element.

void Reset():
Sets the enumerator to the initial position, which is before the first element in the collection (-1)

object Current {get;}:
Gets the current element in the collection. Throws Exception Type InvalidOperationException.

To successfully implement an enumerator wemust keep in mind the following protocol. After an enumerator iscreated or after a Reset, MoveNext must be called to advance theenumerator to the first element of the collection before reading thevalue of Current. Current throws an exception if the last call toMoveNext returns false. Current does not move the position of theenumerator.

This is by no means a thorough discussion on implementing enumeration, more an introduction to using enumerators with foreach.

Here is an example of the changes required to implement an enumerator for use with the foreach construct.

namespace MyFruitBasket
{
public class Fruit
{
//this is a bad way to declare fields in a class
//but this is just an example
public string name;
public bool ripe;
public int num;

public Fruit(string nme, bool rp, int n)
{
name = nme;
ripe = rp;
num = n;
}
}

The Fruits collection implements the IEnumerable and IEnumerator interfaces.

public class Fruits :IEnumerable,IEnumerator
{
Fruit[] fruitArray;
//current position in array set to initial position
int position = -1;
//Create a basket of fruit
public Fruits()
{
fruitArray = new Fruit[3];
fruitArray[0] = new Fruit("Banana",false,3);
fruitArray[1] = new Fruit("Apples",true,5);
fruitArray[2] = new Fruit("Oranges",true,3);
}

//Implement IEnumerable

public IEnumerator GetEnumerator()
{
return (IEnumerator)this;
}

//Implement IEnumerator
public bool MoveNext()
{
position++;
if (position < fruitArray.Length)
{
return true;
}
else
{
return false;
}
}
public void Reset()
{
position = -1;
}
public object Current
{
get{return fruitArray[position];}
}
}

class FruitBar
{
static void Main(string[] args)
{
Fruits fruitbasket = new Fruits();
//Present only the ripe fruit
foreach (Fruit f in fruitbasket)
{
if (f.ripe == true)
Console.WriteLine("Name : {0}",f.name);
Console.WriteLine("Amount : {0}",f.num);
}
string x = Console.ReadLine();
}
}
}

I hope this has been of some help.