一、Enumerator 接口

实现了 IEnumerator 接口的枚举器包含3个函数成员：Current、MoveNext 以及 Reset。

1）Current： 返回序列中当前位置项的属性。

• 只读属性。
• 返回 Object 类型。可以返回对应的可枚举类型。

2）MoveNext： 枚举器位置移到集合中下一个元素的方法，返回值为 bool，返回值代表位置的状态，是有效位置还是到末尾项的位置。

• 返回值为 true，说明新的位置是有效的。
• 返回值为 false，说明新的位置无效，也有可能到了末尾的位置。
• 枚举器的原始位置在序列中的第一项之前，因此 MoveNext 必须在第一次使用 Current 之前调用。

3）Reset： 把位置重置为原始状态的方法。

二、IEnumberable 接口

可枚举类型之所以能通过 GetEnumerator 方法来获取枚举器对象，是因为 IEnumberable 接口里有这个方法，并且可枚举类型实现了 IEnumberable 接口的类。

class MyClass:IEnumerable
{
public IEnumberator GetEnumerator{...}
}

使用 IEnumerbalbe 和 IEnumerator 的示例

    //枚举器class ColorEnumberator : IEnumerator{string[] colors;int position = -1;public ColorEnumberator(string[] theColors){colors = new string[theColors.Length];for (int i = 0; i < theColors.Length; i++)colors[i] = theColors[i];}public object Current{get{if(position == -1)throw new InvalidOperationException();if(position >= colors.Length)throw new InvalidOperationException();return colors[position];}}public bool MoveNext(){if(position < colors.Length - 1){position++;return true;}else{return false;}}public void Reset(){position = -1;}}//可枚举类型class  Spectrum:IEnumerable{string[] Colors = { "violet", "blue", "cyan", "green", "yellow", "orange", "red" };public IEnumerator GetEnumerator(){//创建自定义枚举器ColorEnumberator 对象return new ColorEnumberator(Colors);//此处断点调试}}class Program{static void Main(string[] args){Spectrum spectrum = new Spectrum();foreach (string color in spectrum)//此处断点调试，可进入到GetEnumerator() 方法里Console.WriteLine(color);Console.ReadKey();}}

IEnumerable： 用来实现可枚举类型对象，并调用 GetEnumerator 方法获取枚举器
IEnumerator： 用来自定一个枚举器类型。

三、泛型枚举接口

泛型枚举接口：

IEnumerable<T>
IEnumerator<T>

对于非泛型接口：

• IEnumerable 接口的 GetEnumerator 方法返回实现 IEnumerator 的枚举器实例；
• 实现 IEnumerator 的类实现了 Current 属性，它返回 object 类型的引用，然后我们必须把它转化为对象的实际类型。

泛型接口继承自非泛型接口。对于泛型接口形式：

• IEnumerable <T> 接口的GetEnumerator 方法返回实现 IEnumertor <T> 接口的枚举器的实例。
• 实现 IEnumertor <T> 的类实现了 Current 属性，它返回实际类型的实例，而不是object 基类的引用。
• 这些是协变接口，所以它们实际声明为 IEnumerable < out T> 、 IEnumertor < out T>

类型安全
==非泛型接口的实现不是类型安全的。==它们返回 object 类型的引用，然后必须转化为实际类型。
泛型接口的枚举器是类型安全的，它返回实际类型的引用。
图19-7实现 IEnumerator 接口的类的结构

图19-7实现 IEnumerable 接口的类的结构

四、迭代器

编译器为我们创建了枚举器和可枚举类型，这种结构叫作迭代器。

1、声明迭代器

以下是声明两个迭代器的版本

版本1

//声明迭代器 BlackAndWhite；
public IEumerator<string> BlackAndWhite()
{
yield return "black";//如果没有返回，则执行下一条返回语句
yield return "gray";
yield return "white";
}

版本2

//声明迭代器 BlackAndWhite；
public IEumerator<string> BlackAndWhite()
{
string[] theColors = { "black","gray","white" };
for(int i = 0;i < theColors.Length;i++)
yield return theColors[i];
//如果没有返回则再遍历一次；如果能返回，则结束后续迭代
}

yield return 在枚举器中的作用： 每遍历一次访问 Current 属性时，就要返回一个新值，而不是一次返回所有元素。

2、迭代器块

迭代器块是有一个或多个 yield 语句的代码块。

迭代器块有3种：

• 方法主体；
• 访问器主体；
• 运算器主体。

迭代器块与其他代码块不同。其他块包含的语句被当作是命令式的。也就是说，先执行代码块的第一个语句，然后执行后面的语句，最后控制离开块。

另一方面，迭代器不是需要再同一时间执行的一串命令式命令，而是声明性的，它描述了希望编译器为我们创建的枚举器类的行为。迭代器块中的代码描述了如何枚举元素。

迭代器块有两个特殊语句。

• yield return 语句指定了序列中要返回的下一项。
• yield break 语句指定再序列中没有其他项。

可以让迭代器产生枚举器或可枚举类型

//产生枚举器的迭代器
public IEnumerator<string> IteratorMethod()
{
yield retrun...
}//产生可枚举类型的迭代器
public IEnumerable<string> IteratorMethod()
{
yield retrun...
}

使用迭代器来创建枚举器

 class  MyClass{public int  CurrentIndex = 0;//由于实现了GetEnumerator方法，MyClass 类是可枚举类型public IEnumerator<string> GetEnumerator(){return BlackAndWhite();//返回枚举器}public IEnumerator<string> BlackAndWhite()//迭代器{yield return "black ";yield return "gray ";yield return "white " ;//返回枚举器 IEnumerator<string>}}class Program{static void Main(string[] args){MyClass mc = new MyClass();foreach (string shade in mc)Console.WriteLine(shade);Console.ReadKey();}}

输出结果：

black
gray
white

问题： BlackAndWhite 的作用是通过迭代器来创建一个枚举器，可 foreach 语句为什么会遍历输出 BlackAndWhite 方法里的所有返回值呢？

要想回答这个问题，以下我就通过把 BlackAndWhite 方法调整为：
（在 MyClass 类添加了一个 变量 CurrentIndex，以追踪枚举器获取当前值的位置）

  public IEnumerator<string> BlackAndWhite()//迭代器{//第一次遍历，返回含有black内容的枚举器yield return "black " + CurrentIndex;CurrentIndex++;//第二次遍历，返回含有gray内容的枚举器yield return "gray " + CurrentIndex;CurrentIndex++;//第三次遍历，返回含有white内容的枚举器yield return "white " + CurrentIndex;//该注释掉的代码块，其输出结果跟以上不含有CurrentIndex的代码相同//迭代器里含有字符串数组，是可枚举类型中的内容//string[] theColors = { "black", "gray", "white" };//for (int i = 0; i < theColors.Length; i++)//    yield return theColors[i];}

输出结果：

black 0
gray 1
white 2

由以上的代码可知，foreach 每次遍历访问元素，首先都要调用一次 BlackAndWhite 方法，然后再返回其枚举器，执行 当前 yield return 之后，不会继续执行下行代码，直到下一次遍历的时候，才会继续下一条 yield return 语句。

使用迭代器来创建可枚举类型

  class  MyClass{public IEnumerator<string> GetEnumerator(){IEnumerable<string> mEnumerable = BlackAndWhite();//获取可枚举类型return mEnumerable.GetEnumerator();//获取枚举器}//IEnumerable<string>：返回可枚举类型public IEnumerable<string> BlackAndWhite(){yield return "black";yield return "gray";yield return "white";}}class Program{static void Main(string[] args){MyClass mc = new MyClass();foreach (string shade in mc)//使用类对象Console.Write($"{ shade }  ");foreach (string shade in mc.BlackAndWhite())//使用枚举器方法Console.Write($"{ shade }  ");Console.ReadKey();}}

输出结果：

black gray white black gray white

3、总结常见迭代器模式

枚举器的迭代器模式

class MyClass
{
public IEnumerator<string> GetEnumerator()
{
return IteratorMethod();
}public IEnumerator<string> IteratorMethod()
{
...
yield return ...;
}
}void Main()
{
MyClass mc = new MyClass();
foreach(string x in mc)
...
}

可枚举类型的迭代器模式

class MyClass
{
public Ienumerator<string> GetEnumerator()
{
return IteratorMethod().GetEnumerator();
}public IEnumerable<string> IteratorMethod()
{
yield return...
}void Main()
{
MyClass mc = new MyClass();
foreach(var string x in mc)
...foreach(string x in mc.IteratorMethod())
...}
}

4、产生多个可枚举类型

使用迭代器来产生具有两个可枚举类型的类。

Specturm 类有两个可枚举类型的迭代器 —— 一个从紫外线到红外线枚举光谱中的颜色，而另一个以逆序进行枚举。Spectrum 类不是可枚举类型，但是它有两个方法返回可枚举类型。

    class Spectrum{string[] colors = { "violet", "blue", "cyan", "green", "yellow", "orange", "red" };//返回可枚举类型public IEnumerable<string> UVtoIR(){for (int i = 0; i < colors.Length; i++)yield return colors[i];}//返回可枚举类型public IEnumerable<string> IRtoUV(){for (int i = colors.Length - 1; i >= 0; i--)yield return colors[i];}}class Program{static void Main(string[] args){Spectrum spectrum = new Spectrum();foreach (string color in spectrum.UVtoIR())Console.Write($"{ color }   ");Console.WriteLine();foreach (string color in spectrum.IRtoUV())Console.Write($"{ color }   ");Console.WriteLine();Console.ReadKey();}}

输出结果：

violet blue cyan green yellow orange red
red orange yellow green cyan blue violet

5、将迭代器作为属性

本例演示两个方面的内容：

• 1）使用迭代器来产生具有两个枚举器的累；
• 2）演示迭代器如何实现为属性而不是方法。

   class Spectrum{bool _listFromUVtoIR;string[] colors = { "violet", "blue", "cyan", "green", "yellow", "orange", "red" };public Spectrum(bool lisatFromUVtoIR){_listFromUVtoIR = lisatFromUVtoIR;}public IEnumerator<string> GetEnumerator(){return _listFromUVtoIR ? UVtoIR : IRtoUV;}public IEnumerator<string> UVtoIR{get{for (int i = 0; i < colors.Length; i++)yield return colors[i];}}public IEnumerator<string> IRtoUV{get{for (int i = colors.Length - 1; i >= 0; i--)yield return colors[i];}}}class Program{static void Main(string[] args){Spectrum startUV = new Spectrum(true);Spectrum startIR = new Spectrum(false);foreach (string color in startUV)Console.Write($"{ color }   ");Console.WriteLine();foreach (string color in startIR)Console.Write($"{ color }   ");Console.WriteLine();Console.ReadKey();}}

输出结果：

violet blue cyan green yellow orange red
red orange yellow green cyan blue violet

6、迭代器的实质

迭代器的其他重要事项

• 迭代器属于 System.Collection.Generic 命名空间里的需要使用 using 指令引入它。
• 在编译器生成的枚举器中，不支持 Reset 方法。它是接口需要的方法，所以实现了它，但调用时总是抛出 System.NotSupportedException 异常。

在后台，由编译器生成的枚举器类是包含4个状态的状态机。

• Before： 首次调用 MoveNext 之前的初始化状态。
• Running： 调用 MoveNext 后进入这个状态。在这个状态中，枚举器检测并设置下一项的位置。在遇到 yield return、yield break 或在迭代器体结束时，退出状态。
• Suspended： 状态机等待下次调用 MoveNext 的状态。
• After： 没有更多项可以枚举的状态。

如果状态机在 Before 或 Suspended 状态时调用了 MoveNext 方法，就转到了 Running 状态。在Running 状态中，它检测集合的下一项并设置位置。

如果有更多项，状态机会转入 Suspended 状态；如果没有更多项，它转入并保持在 After 状态。