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

转自： http://wdxinren.cnblogs.com/archive/2005/07/12/191652.html

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

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

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

泛型和非泛型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#迭代器被设计来帮助避免这些问题，（并且）以一种简单直观的方式实现健壮的枚举和枚举器。
 

 

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));
    }
}

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();
    }
}

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

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

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];
            }
        }
    }
}

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

以下的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

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

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