CSharp2-迭代器学习总结｜默然的博客

一直对迭代器处于能用的层次，这次准备深入探索下迭代器的实现原理。

在.net中，一个类实现了IEnumerable接口，那它就可以被迭代。在IEnumerable中只包含了一个接口方法需要被实现：IEnumerator GetEnumerator();，而返回的就是实现了IEnumerator接口的对象。

IEnumerable与IEnumerator的关系，犹如：一本书与一个书签。IEnumerator记录当前的位置，其每次调用MoveNext(),书签向前移动一个位置。当然一个IEnumerable中可以有多个IEnumerator。

从C#1时代foreach就已经实现了对迭代器的支持。

C#1手写一个迭代器

在C# 1时代没有 yield 关键字，手写一个迭代器编码量还是多了挺多的。

// 自定义迭代器
public class MyEnumerable : IEnumerable<string>
{
    private readonly List<string> datas;
    public MyEnumerable(List<string> datas)
    {
        this.datas = datas;
    }
    public IEnumerator<string> GetEnumerator()
    {
        return new MyEnumerator(datas);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    internal class MyEnumerator: IEnumerator<string>
    {
        // 迭代数据
        private readonly List<string> _list;
        // 当前迭代到的位置
        private int _state;

        public MyEnumerator(List<string> datas)
        {
            _list = datas;
            _state = -1;
        }
        object IEnumerator.Current => Current;

        public string Current{
            get
            {
                if(_state == -1 || _state >= _list.Count)
                {
                    throw new InvalidOperationException();
                }
                return _list[_state];
            }
        }

        // 向后移动
        public bool MoveNext()
        {
            if(_state != _list.Count)
            {
                _state++;
            }
            return _state < _list.Count;
        }

        public void Reset()
        {
            _state = -1;
        }
    }
}

C#2使用yield简化上面迭代器

使用yield关键字告诉编译器：这是一个需要执行的迭代块。

static IEnumerable<int> GetEnumerable()
{
    for (int i = 0; i < datas.Count; i++)
    {
        yield return datas[i];
    }
}

用IL看看编译后生成的代码啥样

[CompilerGenerated]
private sealed class <GetEnumerable>d__1 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
{
    private int <>1__state;
    private int <>2__current;
    private int <>l__initialThreadId;
    private int <i>5__2;

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

    object IEnumerator.Current
    {
        [DebuggerHidden]
        [return: Nullable(0)]
        get { return <>2__current; }
    }

    [DebuggerHidden]
    public <GetEnumerable>d__1(int <>1__state)
    {
        this.<>1__state = <>1__state;
        <>l__initialThreadId = Environment.CurrentManagedThreadId;
    }

    [DebuggerHidden]
    void IDisposable.Dispose() { }

    private bool MoveNext()
    {
        switch (<>1__state)
        {
        default:
            return false;
        case 0:
            <>1__state = -1;
            <i>5__2 = 0;
            break;
        case 1:
            <>1__state = -1;
            <i>5__2++;
            break;
        }
        if (<i>5__2 < 100)
        {
            <>2__current = <i>5__2;
            <>1__state = 1;
            return true;
        }
        return false;
    }

    bool IEnumerator.MoveNext()
    {
        //ILSpy generated this explicit interface implementation from .override directive in MoveNext
        return this.MoveNext();
    }

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

    [DebuggerHidden]
    IEnumerator<int> IEnumerable<int>.GetEnumerator()
    {
        if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
        {
            <>1__state = 0;
            return this;
        }
        return new <GetEnumerable>d__1(0);
    }

    [DebuggerHidden]
    IEnumerator IEnumerable.GetEnumerator() { return ((IEnumerable<int>)this).GetEnumerator(); }
}

private static void Main(string[] args)
{
    foreach (int item in GetEnumerable())
    {
        Console.WriteLine(item);
    }
}

[IteratorStateMachine(typeof(<GetEnumerable>d__1))]
private static IEnumerable<int> GetEnumerable()
{
    return new <GetEnumerable>d__1(-2);
}

迭代器的调用步骤

网上有个挺好的例子，借鉴下。可以得出以下结论：

1. 调用CreateEnumerable()并不会执行内部方法，而是在首次 MoveNext() 时才进行执行。
2. 代码执行到 yield return 后就会停止向下执行，而是等到再次调用MoveNext()才会继续执行。
3. 在一个方法中可以多处进行 yield return 语句。
4. 代码不会在 yield return 时结束，而是在 MoveNext() 返回false时结束。

class Program
{
    private static readonly string Padding = new string(' ', 30);
    static void Main(string[] args)
    {
        IEnumerable<int> iterable = CreateEnumerable();
        IEnumerator<int> iterator = iterable.GetEnumerator();
        Console.WriteLine("start to iterate");
        while (true)
        {
            Console.WriteLine("calling MoveNext()....");
            bool moveNext = iterator.MoveNext();
            Console.WriteLine($"....MoveNext result={moveNext}");
            if (!moveNext)
            {
                break;
            }
            Console.WriteLine("fetching current value....");
            Console.WriteLine($"current value={iterator.Current} ");
        }            
        Console.ReadKey();
    }

    static IEnumerable<int> CreateEnumerable()
    {
        Console.WriteLine($"{Padding} start of CreateEnumerable()");
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine($"{Padding} about to yield {i}");
            yield return i;
            Console.WriteLine($"{Padding} after yield");
        }
        Console.WriteLine($"{Padding} yielding final value");
        yield return -1;
        Console.WriteLine($"{Padding} End of CreateEnumerable()");
    }
}


/**
执行结果如下：
start to iterate
calling MoveNext()....
                               start of CreateEnumerable()
                               about to yield 0
....MoveNext result=True
fetching current value....
current value=0
calling MoveNext()....
                               after yield
                               about to yield 1
....MoveNext result=True
fetching current value....
current value=1
calling MoveNext()....
                               after yield
                               about to yield 2
....MoveNext result=True
fetching current value....
current value=2
calling MoveNext()....
                               after yield
                               yielding final value
....MoveNext result=True
fetching current value....
current value=-1
calling MoveNext()....
                               End of CreateEnumerable()
....MoveNext result=False
*/

相关阅读

• 设计模式-单例模式
• 设计模式-工厂模式