（九）枚举器和迭代器（2）

一、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 状态。