C#2.0介绍之Iterators(迭代器)

C#的foreach语句常用来迭代可枚举的集合的元素。为了实现可枚举，一个集合必须有一个无参的GetEnumerator方法，这个方法返回一个枚举器。通常，枚举器比较难实现，但是，用迭代器来简化（枚举器）的任务十分有意义。

一个迭代器是产生一个有序的值序列的一个语句块 。一个迭代器由出现一个或者多个yield语句而区别于一般的语句块：

·         Yield return 语句产生迭代的下一个值。

·         Yield break 语句指出这个迭代结束。

只要函数成员的返回类型是枚举器接口或者enumerable接口中的一个，那么一个迭代器就可以被用作函数成员体。

重要的是明白一个迭代器不是一种成员，而是一种实现函数成员的手段。一个通过迭代器实现的成员能被其他成员覆盖或者重载，而那些成员可能是迭代器实现的，也可能不是迭代器实现的。

以下的Stack<T>类使用迭代器实现它的GetEnumerator方法。迭代器自顶向下枚举栈里的元素。

using System.Collections.Generic;
public class Stack<T>: IEnumerable<T>
{
    T[] items;
    int count;
    public void Push(T data) {}
    public T Pop() {}
    public IEnumerator<T> GetEnumerator() {
        for (int i = count – 1; i >= 0; --i) {
            yield return items[i];
        }
    }
}

GetEnumerator方法的出现使Stack<T>成为一个可枚举的类型，以允许Stack<T>的实例可以用在foreach语句里。以下例子把0-9这些值压入一个整数栈，然后使用foreach循环自顶向下显示值。

using System;
class Test
{
    static void Main() {
        Stack<int> stack = new Stack<int>();
        for (int i = 0; i < 10; i++) stack.Push(i);
        foreach (int i in stack) Console.Write("{0} ", i);
        Console.WriteLine();
    }
}

例子的输出是：

9 8 7 6 5 4 3 2 1 0

Foreach语句隐式调用集合的无参GetEnumerator方法来获取枚举器。只能有一个无参GetEnumerator方法被集合定义，不过它经常有多种方式来进行枚举以及多种方法来通过参数控制枚举。在这些情况下，一个集合能使用迭代器来实现返回enumerable接口的属性或者方法。比如说，Stack<T>可能有两个属性，TopToBottom 和 BottomToTop，返回类型IEnumerable<T>：

using System.Collections.Generic;
public class Stack<T>: IEnumerable<T>
{
    T[] items;
    int count;
    public void Push(T data) {}
    public T Pop() {}
    public IEnumerator<T> GetEnumerator() {
        for (int i = count – 1; i >= 0; --i) {
            yield return items[i];
        }
    }
    public IEnumerable<T> TopToBottom {
        get {
            return this;
        }
    }
    public IEnumerable<T> BottomToTop {
        get {
            for (int i = 0; i < count; i++) {
                yield return items[i];
            }
        }
    }
}

TopToBottom 属性的get访问器只是返回this，因为栈自身是一个enumerable。BottomToTop属性使用C#迭代器返回一个enumerable。以下的例子展示怎么使用属性以两种不同的顺序枚举元素：

using System;
class Test
{
    static void Main() {
        Stack<int> stack = new Stack<int>();
        for (int i = 0; i < 10; i++) stack.Push(i);
        foreach (int i in stack.TopToBottom) Console.Write("{0} ", i);
        Console.WriteLine();
        foreach (int i in stack.BottomToTop) Console.Write("{0} ", i);
        Console.WriteLine();
    }
}

当然，这些属性也能使用在foreach语句之外。以下例子传递调用属性的结果（作为参数）给（独立的）Print方法。这个例子还展示了一个迭代器用作为FromToBy方法体，接受参数。

using System;
using System.Collections.Generic;
class Test
{
    static void Print(IEnumerable<int> collection) {
        foreach (int i in collection) Console.Write("{0} ", i);
        Console.WriteLine();
    }
    static IEnumerable<int> FromToBy(int from, int to, int by) {
        for (int i = from; i <= to; i += by) {
            yield return i;
        }
    }
    static void Main() {
        Stack<int> stack = new Stack<int>();
        for (int i = 0; i < 10; i++) stack.Push(i);
        Print(stack.TopToBottom);
        Print(stack.BottomToTop);
        Print(FromToBy(10, 20, 2));
    }
}

泛型和非泛型enumerable接口包含一个单独的成员，即一个不带任何参数GetEnumerator方法，这个方法返回一个枚举器接口。一个enumerable相当于一个枚举器工厂。当每次它们的GetEnumerator方法被调用，要适当地实现enumerables来获得独立的枚举器。假设enumerable的内状态在两次调用GetEnumerator没有变化，两个返回的枚举器应该产生以相同顺序排列的相同值集合。甚至枚举器的生存期以下面的代码实例交替, 这点也必须保持：

using System;
using System.Collections.Generic;
class Test
{
    static IEnumerable<int> FromTo(int from, int to) {
        while (from <= to) yield return from++;
    }
    static void Main() {
        IEnumerable<int> e = FromTo(1, 10);
        foreach (int x in e) {
            foreach (int y in e) {
                Console.Write("{0,3} ", x * y);
            }
            Console.WriteLine();
        }
    }
}

以上代码输出一个从整数1到10的简单的乘法表。注意FromTo方法只被调用一次来获取enumerable。然而，e.GetEnumerator()被调用多次（被foreach语句）来获取多个等价枚举器。

这些枚举器都封装迭代器指定的代码在FromTo的声明里。注意迭代器代码修改了from参数。然而，枚举器独立运作，因为每个枚举器拥有了它自己的from和to参数的副本。在实现enumerables和枚举器时，枚举器之间的过渡状态的共享是应该被避免的一些细微的缺陷中的一个。C#迭代器被设计来帮助避免这些问题，（并且）以一种简单直观的方式实现健壮的枚举和枚举器。




说明：文中的enumerable没有翻译出来，因为本来这个词是形容词，可原文中大量作为名词在使用，估计意思是可枚举类型，但只是个人猜测，所以还是使用原词，大家可以给出自己的理解。