C# 枚举和迭代器

声明

本文内容来自微软 MVP solenovex 的视频教程——真会C#? - 第4章 进阶C#其它内容，大致和第 3 课—— 4.6 枚举和迭代器 对应。可在 GitHub 中查看 C# 视频教程的配套PPT

本文主要包括以下内容：

1. 枚举器 Enumerator
2. 集合初始化器
3. 迭代器 Iterators
4. 迭代器的语义
5. 组合序列

枚举器 Enumerator

枚举器是一个只读的，作用于一序列值的、只能向前的游标。枚举器是一个实现了下列任意一个接口的对象：

System.Collections.IEnumerator
System.Collections.Generic.IEnumerator 

技术上来说，任何一个含有名为MoveNext方法和名为Current的属性的对象，都会被当作枚举器来对待。foreach语句会迭代可枚举的对象（enumerable object）。可枚举的对象是一序列值的逻辑表示。它本身不是游标，它是一个可以基于本身产生游标的对象。

可枚举对象 enumerable object

一个可枚举对象可以是(下列任意一个)：

• 实现了IEnumerable或者IEnumerable的对象
• 有一个名为GetEnumerator的方法，并且该方法返回一个枚举器(enumerator)

IEnumerator 和 IEnumerable 是定义在 System.Collections 命名空间下的。IEnumerator 和IEnumerable 是定义在 System.Collections.Generic 命名空间下的。

枚举模式 enumeration pattern

class Enumerator // Typically implements IEnumerator or IEnumerator
{
    public IteratorVariableType Current { get {...} }
    public bool MoveNext() {...}
}

class Enumerable // Typically implements IEnumerable or IEnumerable
{
    public Enumerator GetEnumerator() {...}
}

注意：如果枚举器（enumerator）实现了IDisposable接口，那么foreach语句就会像
using语句那样，隐式的dispose掉这个 enumerator 对象。

foreach (char c in "beer")
    Console.WriteLine (c);
    
using (var enumerator = "beer".GetEnumerator())
    while (enumerator.MoveNext())
    {
        var element = enumerator.Current;
        Console.WriteLine (element);
    }

集合初始化器

你可以只用一步就把可枚举对象进行实例化并且填充里面的元素：

using System.Collections.Generic;
...
List list = new List {1, 2, 3};

但是编译器会把它翻译成：

using System.Collections.Generic;
...
List list = new List();
list.Add (1);
list.Add (2);
list.Add (3);

上例中，要求可枚举对象实现了System.Collections.IEnumerable接口，并且他还有一个可接受适当参数的Add方法。

var dict = new Dictionary()
{
    { 5, "five" },
    { 10, "ten" }
};

// succinctly
var dict = new Dictionary()
{
    [3] = "three",
    [10] = "ten"
};

迭代器 Iterators

foreach语句是枚举器（enumerator）的消费者，而迭代器（iterator）是枚举器的生产者。

yield return语句表达的意思是：这是你向我请求从枚举器产生的下一个元素。每逢遇到yield 语句，控制权都会回归到调用者那里，但是被调用这的状态还是会保持的，这样的话可以保证当调用者列举出下一个元素的时候，方法可以继续执行。这个状态的生命周期被绑定到了枚举器上。这样的话，当调用者完成枚举动作之后，状态可以被释放。

using System;
using System.Collections.Generic;
class Test
{
    static void Main()
    {
        foreach (int fib in Fibs(6))
            Console.Write (fib + " ");
    }
    
    static IEnumerable Fibs (int fibCount)
    {
        for (int i = 0, prevFib = 1, curFib = 1; i < fibCount; i++)
        {
            yield return prevFib;
            int newFib = prevFib+curFib;
            prevFib = curFib;
            curFib = newFib;
        }
    }
}

// OUTPUT: 1 1 2 3 5 8

原理解释

编译器把迭代方法转换成私有的、实现了IEnumerable或IEnumerator的类。迭代器块内部的逻辑被反转并且被切分到编译器生成的枚举器类里面的MoveNext方法和Current属性里。这意味着当你调用迭代器方法时，你所做的实际就是对编译器生成的类进行实例化；运行的代码里没有一行是你写的。你写的代码仅会在对结果序列进行枚举的时候才会运行，例如使用foreach语句。

迭代器的语义

迭代器（iterator）是含有一个或多个yield语句的方法、属性或索引器。迭代器必须返回下面四个接口中的一个（否则编译器会报错）：

• System.Collections.IEnumerable // Enumerable interfaces
• System.Collections.Generic.IEnumerable // Enumerable interfaces
• System.Collections.IEnumerator // Enumerator interfaces
• System.Collections.Generic.IEnumerator // Enumerator interfaces

根据迭代器返回的是enumerable接口还是enumerator接口，迭代器会拥有不同的语义。

多个yield语句

方法里可以含有多个yield语句：

class Test
{
    static void Main()
    {
        foreach (string s in Foo())
            Console.WriteLine(s); // Prints "One","Two","Three"
    }
    
    static IEnumerable Foo()
    {
        yield return "One";
        yield return "Two";
        yield return "Three";
    }
}

yield break

yield break语句表示迭代器块会提前退出，不再返回更多的元素。

static IEnumerable Foo (bool breakEarly)
{
    yield return "One";
    yield return "Two";
    if (breakEarly)
        yield break;
    yield return "Three";
}

return语句在迭代器块里面是非法的，你必须使用yield break代替。

迭代器和try/catch/finally块

yield return语句不可以出现在含有catch子句的try块里面：

IEnumerable Foo()
{
    try { yield return "One"; } // Illegal
    catch { ... }
}

yield return 也不能出现在catch或者finally块里面。但是 yield return可以出现在只含有finally块的try块里面：

IEnumerable Foo()
{
    try { yield return "One"; } // OK
    finally { ... }
}

当消费的枚举器到达序列终点或被disposed的时候，finally块里面的代码会执行。如果你提前进行了break，那么foreach语句也会dispose掉枚举器，所以用起来很安全。

当显式的使用枚举器的时候，通常会犯这样一个错误：没有dispose掉枚举就不再用它了，这就绕开了finally块。针对这种情况，你可以使用using语句来规避风险：

string firstElement = null;
var sequence = Foo();
using (var enumerator = sequence.GetEnumerator())
    if (enumerator.MoveNext())
        firstElement = enumerator.Current;

组合序列

迭代器是高度可组合的。

using System;
using System.Collections.Generic;
class Test
{
    static void Main()
    {
        foreach (int fib in EvenNumbersOnly (Fibs(6)))
            Console.WriteLine (fib);
    }
    
    static IEnumerable Fibs (int fibCount)
    {
        for (int i = 0, prevFib = 1, curFib = 1; i < fibCount; i++)
        {
            yield return prevFib;
            int newFib = prevFib+curFib;
            prevFib = curFib;
            curFib = newFib;
        }
    }
    
    static IEnumerable EvenNumbersOnly (IEnumerable sequence)
    {
        foreach (int x in sequence)
            if ((x % 2) == 0)
                yield return x;
    }
}

上例中的每个元素直到最后时刻才会被计算，也就是被MoveNext()操作请求的时候。

Composing sequences

参考

Iterators (C#)
System.Collections.Generic Namespace
IEnumerable Interface
IEnumerator Interface
yield (C# Reference)