C#迭代器

1. 概述

迭代器用于遍历集合。迭代器可定义为方法或get访问器。在event, 实例构造函数，静态构造函数以及静态析构函数中不能使用迭代器。

yield 关键字专门为迭代器而设计。通过 yield定义迭代器，在实现IEnumerable 和 IEnumerator 接口以自定义集合时无需添加其他显式类(保存枚举状态)。

yield 语句有两种形式：

yield return <expression>;

yield break;

yield return 语句一次返回一个元素：foreach 语句或LINQ查询每次迭代都会调用对应迭代方法，该迭代方法运行到 yield return 语句时，会返回一个expression，并保留当前的运行位置，下次调用迭代器函数时直接从该位置开始。

yield break 语句用于终止迭代。

迭代器方法和get访问器

迭代器的声明必须满足以下条件：

• 返回类型必须为IEnumerable, IEnumerable<T>或IEnumerator<T>.
• 声明中不能有ref或out参数。

返回IEnumerable或IEnumerator的迭代器，其yield类型为object。如果迭代器返回的类型为IEnumerable<T>或IEnumerator<T>，则必须把yield return语句的表达式类型隐式转换为泛型类型参数的类型。

具有以下特点的方法不能包含yield return或yield break语句：

• 匿名方法。
• 包含unsafe块的方法。

异常处理

不能将yield return语句放在try-catch块中，但可以放在try-finally语句的try块中。

yield break语句可放在try块或catch块中，但不能放在finally块中。

如果foreach语句(迭代器之外)发生异常，将执行迭代器的finally块。

实现

虽然我们以方法的形式定义迭代器，但是编译器会将其转换为嵌套类。该类会对迭代器的位置进行了记录。

在为类创建迭代器时，不用完全实现IEnumerator接口。当编译器检测到迭代器时，会自动为生成IEnumerator或IEnumerator<T>接口的Current, MoveNext以及Dispose方法。

迭代器不支持IEnumerator.Reset方法，要重新遍历，必须获取一个新的迭代器。

下面代码先从一个迭代器返回IEnumerable<string>，然后遍历其元素：

IEnumerable<string> elements = MyIteratorMethod();

foreach (string element in elements)

{

   …

}

调用MyIteratorMethod时不执行实际操作，在foreach循环时，为elements调用MoveNext方法，才真正执行遍历操作，直至下一个yield return 语句。

在foreach循环的每个后续迭代中，迭代器主体的执行将从它暂停的位置继续，直至到达yield return语句后才会停止。在到达迭代器方法的结尾或yield break语句时，foreach循环完成。

2. 示例

public class PowersOf2

{

    static void Main()

    {

        // Display powers of 2 up to the exponent of 8:

        foreach (int i in Power(2, 8))

        {

            Console.Write("{0} ", i);

        }

    }



    public static System.Collections.IEnumerable<int> Power(int number, int exponent)

    {

        int result = 1;



        for (int i = 0; i < exponent; i++)

        {

            result = result * number;

            yield return result;

        }

    }



    // Output: 2 4 8 16 32 64 128 256

}

上例中，for循环包含一个yield return语句。Main中的foreach循环每次迭代都会调用Power迭代器函数。对迭代器函数的每次调用都会从上次结束的地方开始。

public static class GalaxyClass

{

    public static void ShowGalaxies()

    {

        var theGalaxies = new Galaxies();

        foreach (Galaxy theGalaxy in theGalaxies.NextGalaxy)

        {

            Debug.WriteLine(theGalaxy.Name + " " + theGalaxy.MegaLightYears.ToString());

        }

    }



    public class Galaxies

    {



        public System.Collections.Generic.IEnumerable<Galaxy> NextGalaxy

        {

            get

            {

                yield return new Galaxy { Name = "Tadpole", MegaLightYears = 400 };

                yield return new Galaxy { Name = "Pinwheel", MegaLightYears = 25 };

                yield return new Galaxy { Name = "Milky Way", MegaLightYears = 0 };

                yield return new Galaxy { Name = "Andromeda", MegaLightYears = 3 };

            }

        }



    }



    public class Galaxy

    {

        public String Name { get; set; }

        public int MegaLightYears { get; set; }

    }

}

上例对get访问器形式的迭代器进行了演示，在该示例中，每个yield return语句返回一个用户自定义类的实例。

2. 创建集合类

在例中，DaysOfTheWeek 类实现了IEnumerable接口，即提供GetEnumerator方法。在迭代DaysOfTheWeek集合类时，编译器会隐式调用GetEnumerator方法，得到IEnumerator。GetEnumerator方法通过yield return语句每次返回一个字符串。

static void Main()

{

    DaysOfTheWeek days = new DaysOfTheWeek();



    foreach (string day in days)

    {

        Console.Write(day + " ");

    }

    // Output: Sun Mon Tue Wed Thu Fri Sat

    Console.ReadKey();

}



public class DaysOfTheWeek : IEnumerable

{

    private string[] days = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };



    public IEnumerator GetEnumerator()

    {

        for (int index = 0; index < days.Length; index++)

        {

            // Yield each day of the week.

            yield return days[index];

        }

    }

}

3. 泛型迭代器

static void Main()

{

    Stack<int> theStack = new Stack<int>();



    //  Add items to the stack.

    for (int number = 0; number <= 9; number++)

    {

        theStack.Push(number);

    }



    // Retrieve items from the stack.

    // foreach is allowed because theStack implements

    // IEnumerable<int>.

    foreach (int number in theStack)

    {

        Console.Write("{0} ", number);

    }

    Console.WriteLine();

    // Output: 9 8 7 6 5 4 3 2 1 0



    // foreach is allowed, because theStack.TopToBottom

    // returns IEnumerable(Of Integer).

    foreach (int number in theStack.TopToBottom)

    {

        Console.Write("{0} ", number);

    }

    Console.WriteLine();

    // Output: 9 8 7 6 5 4 3 2 1 0



    foreach (int number in theStack.BottomToTop)

    {

        Console.Write("{0} ", number);

    }

    Console.WriteLine();

    // Output: 0 1 2 3 4 5 6 7 8 9



    foreach (int number in theStack.TopN(7))

    {

        Console.Write("{0} ", number);

    }

    Console.WriteLine();

    // Output: 9 8 7 6 5 4 3



    Console.ReadKey();

}



public class Stack<T> : IEnumerable<T>

{

    private T[] values = new T[100];

    private int top = 0;



    public void Push(T t)

    {

        values[top] = t;

        top++;

    }

    public T Pop()

    {

        top--;

        return values[top];

    }



    // This method implements the GetEnumerator method. It allows

    // an instance of the class to be used in a foreach statement.

    public IEnumerator<T> GetEnumerator()

    {

        for (int index = top - 1; index >= 0; index--)

        {

            yield return values[index];

        }

    }



    IEnumerator IEnumerable.GetEnumerator()

    {

        return GetEnumerator();

    }



    public IEnumerable<T> TopToBottom

    {

        get { return this; }

    }



    public IEnumerable<T> BottomToTop

    {

        get

        {

            for (int index = 0; index <= top - 1; index++)

            {

                yield return values[index];

            }

        }

    }



    public IEnumerable<T> TopN(int itemsFromTop)

    {

        // Return less than itemsFromTop if necessary.

        int startIndex = itemsFromTop >= top ? 0 : top - itemsFromTop;



        for (int index = top - 1; index >= startIndex; index--)

        {

            yield return values[index];

        }

    }



}

在上面的例子中，Stack<T>泛型类实现了IEnumerable<T>泛型接口。Push方法将T类型值添加到数组，GetEnumerator方法通过yield return语句包含数组值。

除了泛型的GetEnumerator方法，还必须实现非泛型的GetEnumerator方法。因为IEnumerable<T>从IEnumerable继承而来。非泛型直接通过泛型实现。

该示例使用命名迭代器以支持对同一集合的多种迭代方式。命名迭代器包括TopToBottom，BottomToTop以及TopN方法。

其中，BottomToTop属性在get访问器中使用了迭代器。