迭代器基础知识

    以前用集合的时候，用foreach进行循环，也没深究里面的实现机制。昨日在博客园上看一大牛的文章，讲述yield return的问题，才知道原来是这样的啊。下面这些概念都摘抄自书上。

1. 基础知识

IEnumerable接口允许使用foreach循环，很多的集合类都实现这个接口，在foreach循环中，并不一定只能用集合类，可以定制类。简述下foreach循环中，迭代一个collectionObject集合的过程如下：

1）调用collectionObject.GetEnumerator()，返回一个IEnumerator引用。这个方法可以通过IEnumerator接口的实现代码来获得，可选的。

2）调用所返回的IEnumerator接口的movenext方法。

3）如果movenext方法返回为true，就使用IEnumerator接口的current属性来回去对象的一个引用，用于foreach循环。

4）重复前面两步，知道movenexr方法返回false为止。直至循环结束。

使用迭代器的两个类型的场合是：

1）如果要迭代一个类，可使用方法GetEnumerator(),其返回类型是IEnumerator

2）如果要迭代一个类成员，例如一个方法，则使用IEnumerable。

2 实例

举例说明

1）迭代一个类成员

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace Ch12Ex01
{
    class Program
    {
 public static IEnumerable GetList()
        {
            Console.WriteLine("GetList  Method");
            yield return "string1";
            yield return "string2";
            yield return "string3";
        }
        static void Main(string[] args)
        {
 var str = GetList();
            Console.WriteLine("Main method");
            foreach (string temp in str)
            {
                Console.WriteLine(temp);
            }
    Console.ReadKey();

        }
    }
}

注意这里，getlist方法在调用的时候并没有运行方法体的内容，而是在迭代的时候才运行。所以输出的结果是先输出main method，在输出getlist method。

2）迭代一个类

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Collections.Generic;
namespace Ch12Ex01
{
    class Primes
    {
        private int min;
        private int max;
        public Primes() : this(2, 100) { }
        public Primes(int minT, int maxT)
        {
            if (minT < 2) min = 2;
            else
            min = minT;
            max = maxT;
        }
        public IEnumerator GetEnumerator()
        {
            for (int i = min; i < max;i++ )
            {
                if (i % 2 == 0 && i % 3 == 0)
                {
                    yield return i;
                }
            }
        }
    }
}

  static void Main(string[] args)
        {
            Primes primes = new Primes(1, 1000);
            foreach (var a in primes)
            {
                Console.WriteLine(a);
            }
            Console.ReadKey();

        }

3 内部实现机制

1）GetList反编译。

internal class Program
{
    // Methods
    public static IEnumerable GetList()
    {
        return new <GetList>d__0(-2);
    }

    private static void Main(string[] args)
    {
        IEnumerable list = GetList();
        Console.WriteLine("Main method");
        foreach (string str in list)
        {
            Console.WriteLine(str);
        }
        Console.ReadKey();
    }

    // Nested Types
    [CompilerGenerated]
    private sealed class <GetList>d__0 : IEnumerable<object>, IEnumerable, IEnumerator<object>, IEnumerator, IDisposable
    {
        // Fields
        private int <>1__state;
        private object <>2__current;
        private int <>l__initialThreadId;

        // Methods
        [DebuggerHidden]
        public <GetList>d__0(int <>1__state)
        {
            this.<>1__state = <>1__state;
            this.<>l__initialThreadId = Thread.CurrentThread.ManagedThreadId;
        }

        private bool MoveNext()
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    Console.WriteLine("GetList  Method");
                    this.<>2__current = "string1";
                    this.<>1__state = 1;
                    return true;

                case 1:
                    this.<>1__state = -1;
                    this.<>2__current = "string2";
                    this.<>1__state = 2;
                    return true;

                case 2:
                    this.<>1__state = -1;
                    this.<>2__current = "string3";
                    this.<>1__state = 3;
                    return true;

                case 3:
                    this.<>1__state = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        IEnumerator<object> IEnumerable<object>.GetEnumerator()
        {
            if ((Thread.CurrentThread.ManagedThreadId == this.<>l__initialThreadId) && (this.<>1__state == -2))
            {
                this.<>1__state = 0;
                return this;
            }
            return new Program.<GetList>d__0(0);
        }

        [DebuggerHidden]
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.System.Collections.Generic.IEnumerable<System.Object>.GetEnumerator();
        }

        [DebuggerHidden]
        void IEnumerator.Reset()
        {
            throw new NotSupportedException();
        }

        void IDisposable.Dispose()
        {
        }

        // Properties
        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }
    }
}

从上面看到编译器生成了一个密封类，类名为<GetList>d__0，在main函数中调用getlist方法，其实只是新建了一个<GetList>d__0对象，当迭代的时候，才执行具体的内容，这也就能解释为啥先输出main method，再输出getlist method。

2）将Prime类进行反编译，如下。

internal class Primes
{
    // Fields
    private int max;
    private int min;

    // Methods
    public Primes() : this(2, 100)
    {
    }

    public Primes(int minT, int maxT)
    {
        if (minT < 2)
        {
            this.min = 2;
        }
        else
        {
            this.min = minT;
        }
        this.max = maxT;
    }

    public IEnumerator GetEnumerator()
    {
        <GetEnumerator>d__0 d__ = new <GetEnumerator>d__0(0);
        d__.<>4__this = this;
        return d__;
    }

    // Nested Types
    [CompilerGenerated]
    private sealed class <GetEnumerator>d__0 : IEnumerator<object>, IEnumerator, IDisposable
    {
        // Fields
        private int <>1__state;
        private object <>2__current;
        public Primes <>4__this;
        public int <i>5__1;

        // Methods
        [DebuggerHidden]
        public <GetEnumerator>d__0(int <>1__state)
        {
            this.<>1__state = <>1__state;
        }

        private bool MoveNext()
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    this.<i>5__1 = this.<>4__this.min;
                    while (this.<i>5__1 < this.<>4__this.max)
                    {
                        if (((this.<i>5__1 % 2) != 0) || ((this.<i>5__1 % 3) != 0))
                        {
                            goto Label_0080;
                        }
                        this.<>2__current = this.<i>5__1;
                        this.<>1__state = 1;
                        return true;
                    Label_0078:
                        this.<>1__state = -1;
                    Label_0080:
                        this.<i>5__1++;
                    }
                    break;

                case 1:
                    goto Label_0078;
            }
            return false;
        }

        [DebuggerHidden]
        void IEnumerator.Reset()
        {
            throw new NotSupportedException();
        }

        void IDisposable.Dispose()
        {
        }

        // Properties
        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }
    }
}

结合上面基础知识部分，就能知道迭代器的工作原理。每次迭代，其实就是执行movenext方法。