迭代器模式随想

一、什么是迭代器模式？

定义：提供一种顺序访问集合的方法，而不暴露集合内部的表示

顺序访问，one by one（挨个访问），不暴露集合内部表示，反映了面向对象程序中的封装性。可以这么理解，一组模特从后台出场，一个接着一个，但是先出场的模特，未必是站在最前面的模特。换句话说，对于观众，你不知道后台模特的特定位置。为什么是顺序访问呢？因为迭代器模式采用的输出机制是内部决定好的，你无法决定。不像字典类型，我传不同的key，可以访问不同的value。我们访问列表，可以直接访问第i个元素，但是迭代器，你想要访问下一个元素，必须把当前的元素访问过后，才能到下一个元素。

二、c#中的迭代器接口

 迭代器接口，可以手动实现调用，如下：

    public class MyIEnumerator : IEnumerator<string>
    {
        string[] types = { "下等马", "上等马", "中等马" };

        int cur = -1;
        public string Current
        {
            get
            {
                return types[cur];
            }
        }
        object IEnumerator.Current
        {
            get
            {
                return this.Current;
            }
        }

        public void Dispose()
        {
        }

        public bool MoveNext()
        {
            if (cur < types.Length - 1)
            {
                cur++;
                return true;
            }
            return false;
        }

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

话说田忌赛马，按一定的出场顺序赢得了齐威王，此策略是由孙膑提出的，再看看调用：

     MyIEnumerator m = new MyIEnumerator();
     while (true)
      {
          if (m.MoveNext()) { Console.WriteLine(m.Current); }
          else break;
      }

显然手动编写代码，比较麻烦，搞不好还弄个数组越界，我们看看c#中可枚举接口：

 此接口只有一个实现迭代器的方法，我们知道凡是实现了这个接口的，都可以用foreach循环，我们把调用迭代器的方法改成foreach自动调用

   public class MyEnumerable : IEnumerable<string>
    {
        public IEnumerator<string> GetEnumerator()
        {
            return new MyIEnumerator();
        }

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

  MyEnumerable a = new MyEnumerable();
   foreach (var item in a)
   {
       Console.WriteLine(item);
   }

可能有人问了，你改成foreach循环和手动循环调用有什么区别？可以这么说吧，foreach进一步简化了调用，你不用控制循环什么时候结束，你也不要操心怎么访问下一个元素。

可见迭代器的调用已经很优雅了，如果迭代器的创建能够简化，那么就更好了，c#中提供了yield关键字。

        public IEnumerator<string> GetEnumerator()
        {
            yield return "下等马";
            yield return "上等马";
            yield return "中等马";
        }

通过6行代码，编译器就为我们创建好了迭代器，如下所示：

public class MyEnumerable : IEnumerable<string>, IEnumerable
{
    // Methods
    [IteratorStateMachine(typeof(<GetEnumerator>d__0))]
    public IEnumerator<string> GetEnumerator()
    {
        yield return "下等马";
        yield return "上等马";
        yield return "中等马";
    }

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

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

        // 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.<>2__current = "下等马";
                    this.<>1__state = 1;
                    return true;

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

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

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

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

        [DebuggerHidden]
        void IDisposable.Dispose()
        {
        }

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

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

有趣的是编译器用switch case 实现MoveNext方法，yield用状态机实现迭代器。

三、理解yield关键字

yield关键字，后面紧跟return 表达式或者break。return 表达式，并没有结束迭代器，只是暂时离开迭代器，在特定情况下(调用MoveNext方法时），又会进入迭代器。可以理解迭代器处于暂停或者挂起状态。break直接结束迭代。

四、迭代器的其它用途

Linq表达式的延迟加载，如果我们有一个数组，想通过Linq过滤一下：

  List<int> ages =new List<int> { 5, 17, 30, 40 };
  var yong = ages.Where(g => g < 18);

  ages.Add(2);

   foreach (var item in yong)
   {
      Console.WriteLine(item);
   }

运行结果：

Where扩展方法只是生成了一个迭代器，告诉这个迭代器原始的集合，以及如何筛选的方法，到调用的时候，才真正的过滤数据，这就是Linq延迟加载的原理。