C#精粹--迭代器

迭代器模式

迭代器是C#里面非常非常非常重要的一个概念，它是序列、LINQ等一系列概念的基础。

手写一个迭代器

class MyIEnumerable : IEnumerable<string>
    {
        public IEnumerator<string> GetEnumerator()
        {
            return new MyEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        internal class MyEnumerator : IEnumerator<string>
        {
            private readonly List<string> _list;

            public string Current
            {
                get
                {
                    if (_state == -1 || _state == _list.Count)
                    {
                        throw new InvalidOperationException();
                    }
                    return _list[_state];
                }
            }

            private int _state;
            object IEnumerator.Current => Current;
            public MyEnumerator()
            {
                _list = new List<string>() { "a", "b", "c", "d", "e", "f" };
                _state = -1;
            }
            public void Dispose()
            {
                Console.WriteLine("dispose");
            }
            public bool MoveNext()
            {
                if (_state != _list.Count)
                {
                    _state++;
                }
                return _state < _list.Count;
            }
            public void Reset()
            {
                throw new NotImplementedException();
            }
        }
    }

上面手写了一个迭代器，在这个迭代器内部嵌套了一个类实现IEnumerator。这是实现迭代器模式的C#标准代码。看起来很臃肿，如果我只想返回几个值，也必须这么写。

yield

C#利用这个关键字大大的简化了实现IEnumerable的步骤。但是编译器为我们在后台做的事情不少。我们慢慢来看。

C#2是利用一个关键字来告诉编译器去后台创建一个状态机。这个关键字是yield，比如下面的例子：

 class Program
    {

        static void Main(string[] args)
        {
            foreach (int item in GetEnumerable())
            {
                Console.WriteLine(item);
            }
        }

        static IEnumerable<int> GetEnumerable()
        {
            for (int i = 0; i < 1000; i++)
            {
                yield return i;
            }
        }

    }

program类中声明了一个GetEnumerable的静态方法，返回一个IEnumerable<int>的实例。关键是在方法内部，出现了yield关键字，这就是告诉编译器要在后台生成一个类来实现迭代器模式，用ILSpy来看一下生成的这个类：

可以看到一个名字为“<GetEnumerable>d_1"的类被编译器生成了。因为我并没有声明这个类。这个类是一个嵌套类，在program类中定义。

这个类的声明如下：

private sealed class <GetEnumerable>d__1 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable

可以看到这个类实现了5个接口：IEnumerable<T>,IEnumerable,IEnumerator<T>,IEnumerator,IDisposable

这个类的结构如下：

它定义了三个字段并实现了接口的所有方法。关键的代码在MoveNext中，看一下：

可以看到在MoveNext中将GetEnumerable方法的逻辑放到了这里，而在GetEnumerable方法的内部，看一看到之前那一坨包含yield return的代码块不见了，而变成这样：

只有一句，就是将编译器生成的类实例化后返回。

具体在实例化这个<GetEnumerable>d__1实例时会传入-1还是-2取决于返回的是一个IEnumerable(-2)还是一个IEnumeartor(-1).

其他具体的可以用ILSpy来查看。ILSpy的地址在github上。

yield return需要注意的事项

从上面的描述可以得到如下信息：

在返回一个IEnumerable或者IEnumerator或他们的泛型等价物的方法中执行yield，编译器就会在后台生成一个状态机，这个状态机实现了上面说的那5个接口IEnumerable<T>,IEnumerable,IEnumerator<T>,IEnumerator,IDisposable。这个状态机的代码和C#1中我们需要手写的实现迭代器的代码基本一样。
如果方法声明的返回类型是非泛型接口，那么迭代器块的生成类型（yield type）是object，否则就是泛型接口的类型参数。例如，如果方法声明为返回IEnumerable<string>，那么就会得到string类型的生成类型。

那么，如果要实现一个迭代器，就要考虑以下事情：

它必须具有某个初始状态，比如上面看到的那个生成类中的<>1__state；
每次调用MoveNext时，在提供下一个值之前（换句话说，就是执行到yield return 语句之前），它需要执行GetEnumerator 方法中的代码；
使用Current属性时，它必须返回我们生成的上一个值；
它必须知道何时完成生成值的操作，以便MoveNext返回false。

对于如何解决第二点提出的问题，从上面的贴图来看，在MoveNext方法中会根据<>1__state的值进入到相应的代码段来执行相应的代码。

迭代器的工作流程

无论返回的是IEnumerable<T>还是IEnumerator<T>，在迭代器的方法里面没有什么区别，区别在于，如果你要枚举这个生成的类，比如说你要使用foreach来遍历，那么最好是返回一个IEnumerable的类型。因为在C#中是否能够遍历一个对象在于这个对象是否实现了一个GetEnumerator的方法（Duck Typing）。而无论它是否实现了那一堆接口。

用一个代码段来说明一下迭代器的执行流程吧：

 class Program
    {
        private static readonly string Padding = new string(' ', 30);
        static void Main(string[] args)
        {
            IEnumerable<int> iterable = CreateEnumerable();
            IEnumerator<int> iterator = iterable.GetEnumerator();
            Console.WriteLine("start to iterate");
            while (true)
            {
                Console.WriteLine("calling MoveNext()....");
                bool moveNext = iterator.MoveNext();
                Console.WriteLine($"....MoveNext result={moveNext}");
                if (!moveNext)
                {
                    break;
                }
                Console.WriteLine("fetching current value....");
                Console.WriteLine($"current value={iterator.Current} ");
            }            
            Console.ReadKey();
        }

        static IEnumerable<int> CreateEnumerable()
        {
            Console.WriteLine($"{Padding} start of CreateEnumerable()");
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine($"{Padding} about to yield {i}");
                yield return i;
                Console.WriteLine($"{Padding} after yield");
            }
            Console.WriteLine($"{Padding} yielding final value");
            yield return -1;
            Console.WriteLine($"{Padding} End of CreateEnumerable()");
        }
    }

上面的代码会输出以下结果：

start to iterate
calling MoveNext()....
                               start of CreateEnumerable()
                               about to yield 0
....MoveNext result=True
fetching current value....
current value=0
calling MoveNext()....
                               after yield
                               about to yield 1
....MoveNext result=True
fetching current value....
current value=1
calling MoveNext()....
                               after yield
                               about to yield 2
....MoveNext result=True
fetching current value....
current value=2
calling MoveNext()....
                               after yield
                               yielding final value
....MoveNext result=True
fetching current value....
current value=-1
calling MoveNext()....
                               End of CreateEnumerable()
....MoveNext result=False

下面是结论：

在第一次调用MoveNext之前， CreateEnumerable中的代码不会被调用。也就是说只有调用MoveNext的时候CreateEnumerable中的代码才会被调用。因为CreateEnumerable中的代码全部被搬到了MoveNext中，CreateEnumerable中的代码只剩下一行return new <GetEnumerable>d_1()；
所有工作在调用MoveNext时就完成了，获取Current的值不会执行任何代码；
在yield return的位置，代码就停止执行，在下一次调用MoveNext时又继续执行。MoveNext----yield return----MoveNext-----yield return循环直到MoveNext返回fanlse。
在一个方法中的不同地方可以编写多个yield return语句；
代码不会在最后的yield return处结束，而是通过返回false的MoveNext调用来结束方法的执行。

遇到try--catch--final怎么办？

首先需要说明的是不能在try-catch块中使用yield return。编译器会提示两个：①不能在包含catch的try块中生成值②不能在catch块中生成值。这也就是说，出现yield关键字的地方不能有catch块。可以使用try--finally块。那么这个话题就变成了：在try--finally块中的执行情况

要离开作用域时，我们习惯用finally块去执行一些代码，它的语义是”最后无论如何都要执行“。

迭代器行为方式和普通的方法不太一样。yield return只是暂时停止了方法，而不是退出了方法，他的意思是说”我还会回来的“。而yield break语句的行为类似于普通的return--退出代码所在的方法。

说一个题外话：break是跳出当前循环，continue是结束一次循环 ,return是退出代码所在的方法。

在try--finally块中的执行情况的结论是无论是yield return还是yield break，在遇到finally的时候总会最终执行finally中的代码。原因是finally被编译器生成一个单独的方法，这个方法会在正常结束时被调用，也会在中途退出的时候被调用，上两张图：

这个是在实现IDisposable接口的方法，看到最下面那个了”<>m__Finally1“么?那是编译器生成的这个状态机的方法，前提如果我们的yield代码块中包含finally块时，这个finally块会被编译器编译成一个单独的方法。这个方法会在正常结束的地方放置，也会在Dispose方法中放置。而使用foreach调用时编译器会在foreach使用结束的时候调用状态机的Dispose方法。也就是说------只要调用者使用了foreach循环，迭代器块中的finally将按照你期望的方式工作。如果你要想手动调用MoveNext方法和Current属性，那么请记得要将代码放到using语句中。using语句会帮助你调用Dispose。

现在总结以下编译器在实现状态机的时候一些要点：

在第一次调用MoveNext之前， Current属性总是返回迭代器产生类型的默认值；
在MoveNext返回false之后， Current属性总是返回最后的生成值；
Reset总是抛出异常，而不像我们手动实现的Reset过程那样，为了遵循语言规范，这是必要的行为；
嵌套类总是实现IEnumerator的泛型形式和非泛型形式（提供给泛型和非泛型的IEnumerable所用）。