在C#中，foreach的使用简化了很多循环语法的书写。如果初学者仅仅把foreach当成for循环的省略写法的话，就显得有点大才小用了。事实上，foreach与“迭代”和“枚举”密切相关。
C#编译器会把foreach语句转换为IEnumerable接口的方法和属性。例如：
foreach (Person p in persons)
{
writeline方法的作用
Console.WriteLine(p);
}
以上代码迭代persons数组中的所有元素，并逐个显示他们。
foreach语句会解析成下面的代码。首先调用GetEnumerator()方法，获得数组的一个枚举。在while循环中（只要MoveNext()返回true），用Current属性访问数组中的元素：
IEnumerator enumerator = persons.GetEnumerator();
while (enumerator.MoveNext())
{
Person p = (Person) enumerator.Current;
Console.WriteLine(p);
}
这里要说明的是。用[]声明数组是C#中使用Array类的记号。Array类实现了IEnumerable接口中的GetEnumerator()方法。使用foreach语句迭代数组，其实是使用了Array类中个GetEnumerator()方法。
也就是说，只要是实现了IEnumerable接口中的GetEnumerator()方法的类，都可以用foreach语句来迭代。
IEnumerable接口中的GetEnumerator()方法是这样定义的：
IEnumerator GetEnumerator()
其返回的类型是一个IEnumerator接口。
IEnumerator接口中的Current属性返回光标所在的元素。
IEnumerator接口中的MoveNext()方法移动到集合的下一个元素上，如果有这个元素，该方法就返回true。如果集合不再有更多的元素，该方法就返回false。
IEnumerator接口中的Reset()方法将光标重新定位于集合的开头。许多枚举会抛出NotSupportedException异常。
在以前，如果我们希望构建支持foreach枚举类型的自定义集合，只能实现IEnumerable接口（可能还有IEnumerable接口）然而，从.NET2.0发布以来，还可以通过迭代器来构建使用foreach的类型。简单来说，迭代器就是这样一个成员方法，它指定了容器内部项被foreach处理时该如何返回。虽然迭代器方法还是必须命名为GetEnumerator()，返回值类型还是必须为IEnumberator类型，但自定义类不需要实现原来那些接口了：
public class Garage
{
private Car[] carArry =new Car[4];
------
//迭代器方法
public IEnumerator GerEnumerator()
{
foreach(car c in carArry)
{
yield return c;
}
}
}
注意这个GetEnumerator（）的实现使用内部foreach逻辑迭代每个子项，使用新的yield返回语法向调用方返回每个Car对象。yield关键字用来向调用方foreach指定返回值。当到达yield返回语句后，当前位置被存储下来，下次调用迭代器会从这个位置开始 执行。迭代器方法不一定要通过foreach关键字来
返回内容。
我们也可以如下定义迭代器方法：
public IEnumerator GetEnumerator()
{
yield return carArry[0];
yield return carArry[1];
yield return carArry[2];
yield return carArry[3];
}
在这个实现中，注意GetEnumerator()方法显式返回新的值给调用者。虽然对于这个实例来说意义不是很大，因为如果我们为carArry成员变量增加更多对象的话，GetEnumerator()方法就会不同步。但是，如果我们希望方法返回能被foreach语法处理的局部数据，这个方法就很有用
构建命名迭代器：还有有趣的一点是，yield关键字从技术上说可以和任何一方法结合使用，无论方法名是什么。这些方法（技术上称为命名迭代器）独特之处在于可以接受许多参数。如果构建命名迭代器的话，需要知道这些方法会返回IEnumerator接口，而不是期望的IEnumerator兼容类型。
迭代器方法的内部表示：如果c#编译器遇到迭代器方法，它就会在定义类型的作用域内动态生成动态生成嵌套类。自动生成的嵌套类为我们实现了GetEnumerator（）、MoveNext（）以及Current成员。（奇怪的是不包含reset（）方法，如果我们尝试调用就会出现运行时异常）。如果将运行程序加载到，就会发现两个嵌套类型，每个都代表了某个迭代器方法需要的逻辑。
记住，如果自定义类型要和c#的foreach关键字一起使用的话，容器就需要定义一个名为GetEnumerator（）的方法，它由IEnumerator接口类型来定制。通常这个方法的实现只是交给保存子对象的内部成员，然而，我们也可以使用yield Return语法来提供多个命名迭代器方法。
下面，我们来写一个实现了IEnumerable接口的类。
public class HelloCollection:IEnumerable
{
public IEnumerator GetEnumerator()
{
yield return "Hello";
yield return "World";
}
}
现在可以用foreach语句迭代了：
static void Main(string[] args)
{
HelloCollection helloCollection=new HelloCollection ();
foreach (string s in helloCollection )
{
Console.WriteLine(s);
}
}
实际上，yield return语句返回集合的一个元素，并移动到下一个元素上。它会将类HelloCollection解析成如下代码：
public class HelloCollection : IEnumerable
{
public IEnumerator GetEnumerator()
{
Enumertor enumerator = new Enumerator();
return enumerator;
}
public class Enumertor : IEnumerator, IDisposable
{
private int state;
private object current;
public Enumertor(int state)
{
this.state = state;
}
}
bool System.Collections .IEnumerator .MoveNext()
{
switch (state)
{
case 0:
current = "Hello";
state = 1;
return true;
case 1:
current = "World";
state = 2;
return true ;
case 2:
break ;
}
return false ;
}
void System.Collections .IEnumerator .Reset()
{
throw new NotSupportedException();
}
object System.Collections .IEnumerator .Current
{
get { return current; }
}
void IDisposable.Dispose()
{
}
}
foreach语句默认用GetEnumerator()方法迭代，也可以自行制定迭代方法。举例：
public class MusicTitles:IEnumerable
{
string[] names = { "Tubular Bells", "Hergest Ridge", "Ommadawn", "Platinum" };
public IEnumerator GetEnumerator()  /*顺序迭代*/
{
for (int i = 0; i < 4; i++)
yield return names[i];
}
public IEnumerator Reverse()  /*逆序迭代*/
{
for (int i = 3; i >= 0; i--)
yield return names[i];
}
}
在foreach语句中不必写明使用GetEnumerator()方法迭代，因为这是默认方法。如下：
static void Main(string[] args)
{
MusicTitles titles = new MusicTitles();
foreach (string title in titles)
{
Console.WriteLine(title);
}
Console.WriteLine();
foreach (string title in titles.Reverse())
{
Console.WriteLine(title);
}
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。