C# in Depth

90 CHAPTER 3 Parameterized typing with generics3.4.3 Generic iterationOne of the most common operations you’ll want to perform on a collection (usuallyan array or a list) is to iterate through all its elements. The simplest way of doing thatis usually to use the foreach statement. In C# 1 this relied on the collection eitherimplementing the System.Collections.IEnumerable interface or having a similarGetEnumerator() method that returned a type with a suitable MoveNext() methodand Current property. The Current property didn’t have to be of type object—andthat was the whole point of having these extra rules, which look odd on first sight. Yes,even in C# 1 you could avoid boxing and unboxing during iteration if you had acustom-made enumeration type.C# 2 makes this somewhat easier, as the rules for the foreach statement have beenextended to also use the System.Collections.Generic.IEnumerable interfacealong with its partner, IEnumerator. These are simply the generic equivalents ofthe old enumeration interfaces, and they’re used in preference to the nongeneric versions.That means that if you iterate through a generic collection of value type elements—List,for example—then no boxing is performed at all. If the oldinterface had been used instead, then although we wouldn’t have incurred the boxingcost while storing the elements of the list, we’d still have ended up boxing them whenwe retrieved them using foreach!All of this is done for you under the covers—all you need to do is use the foreachstatement in the normal way, using the type argument of the collection as the type ofthe iteration variable, and all will be well. That’s not the end of the story, however. Inthe relatively rare situation that you need to implement iteration over one of your owntypes, you’ll find that IEnumerable extends the old IEnumerable interface, whichmeans you’ve got to implement two different methods:IEnumerator GetEnumerator();IEnumerator GetEnumerator();Can you see the problem? The methods differ only in return type, and the rules ofC# prevent you from writing two such methods normally. If you think back to section2.2.2, we saw a similar situation—and we can use the same workaround. If youimplement IEnumerable using explicit interface implementation, you can implementIEnumerable with a “normal” method. Fortunately, because IEnumeratorextends IEnumerator, you can use the same return value for both methods, andimplement the nongeneric method by just calling the generic version. Of course,now you need to implement IEnumerator and you quickly run into similar problems,this time with the Current property.Listing 3.9 gives a full example, implementing an enumerable class that always justenumerates to the integers 0 to 9.Listing 3.9 A full generic enumeration—of the numbers 0 to 9class CountingEnumerable: IEnumerable{public IEnumerator GetEnumerator()BImplementsIEnumerableimplicitlyLicensed to Rhona Hadida