实现IEnumerator 已支持foreach

      本文严重参考了 笔记：IEnumerable和IEnumerator（包括泛型版）,  另外caozhy在BBS也有一段总结(链接地址), 可以参考

1.  一个对象可以用foreach遍历, 必须包含以下3个：
    一个GetEnumerator()方法， 无参数，返回类型任意
    Current属性，只有get方法，不能有set方法(编译器也不允许)，返回类型任意
    MoveNext()方法，无参数, 判断是否到遍历完毕，返回类型bool
    为了让Current属性知道应该返回哪个值了, 和 辅助MoveNext判断是否遍历完毕, 通常还会有个 int index, 虽然不必须但很有必要

2.  实现了上面3个方法和属性, 代码就可以使用foreach 了, 编译器会自动去绑定，因此不需要IEnumerable和IEnumerator。
    其实接口的本质就是让编译器去绑定一个对象的方法，在这里，C#编译器的确不依赖接口

    //手动让一个int数组支持foreach    class A    {        int[] array = new int[]{1,2,3,4,5};        int index=-1;        public A GetEnumerator() { return this; }        public int Current { get { return array[index]; } }        public bool MoveNext() { index++; return index < array.Length ? true : false; }    }    class TaskThread    {        static void Main()        {            A a = new A();            foreach (var s in a)                Console.WriteLine(s);        }    }

3.  IEnumerable接口指明需要GetEnumerator()
    IEnumerator接口指明需要Current、MoveNext(), 但VS中点击 "实现接口", 通常还会生成Reset()方法.
    一般我们对一个数组变量连续2次使用 foreach, 就会循环两遍; 如果你仅实现了上面的三个方法和属性, 连续2次foreach却不能达到要求

    class A    {        int[] array = new int[]{1,2,3,4,5};        int index=-1;        public A GetEnumerator() { return this; }        public int Current { get { return array[index]; } }        public bool MoveNext()         {             index++;            if (index < array.Length)                return true;            else            {                //Reset();                return false;            }        }        //private void Reset()        //{        //    index = -1;        //}    }    class TaskThread    {        static void Main()        {            A a = new A();            foreach (var s in a)                Console.WriteLine(s);            Console.WriteLine("循环第二次");            foreach (var s in a)                Console.WriteLine(s);        }    }

    原因是: 第一次循环结束后, index就已经等于array.Length了; 第二次循环一开始, foreach会首先进行MoveNext()判断, 判断结果为false, 当然立马退出咯
    当把注释掉的 Reset() 方法恢复后, 就可以得到正常结果了.

4.  IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接，可以通过IEnumerable的GetEnumerator()得到IEnumerator对象
    那为什么集合类不直接继承（支持）IEnumerator<T>和IEnumerator接口？
    假如同时有两个循环交错遍历同一个集合（一个foreach嵌套了另外一个foreach），那么集合必须维持当前元素的一个状态指示器，确保当调用MoveNext()方法时，能正确定位下一个元素。
    为了解决这个问题，集合类不直接支持IEnumerator<T>和IEnumerator接口。而是通过IEnumerable的GetEnumerator返回一个新的IEnumerator对象来负责维护循环遍历的状态，IEnumerator（迭代器，或者叫枚举数）相当于一个“游标”(cursor)或者“书签”。可以有多个书签，移动每个书签都可独立于其他书签来遍历集合
下面的代码是双线程同时访问集合

    class A    {        int[] array = new int[]{1,2,3,4,5};        int index=-1;        public A GetEnumerator() { return this; }        public int Current { get { return array[index]; } }        public bool MoveNext()         {             index++;            if (index < array.Length)                return true;            else            {                Reset();                return false;            }        }        private void Reset()        {            index = -1;        }    }    class TaskThread    {        static A a = new A();        static void Main()        {            Thread m = new Thread(GetSum);            Thread n = new Thread(GetSum);            m.Start();            n.Start();        }        static void GetSum()        {            int sum = 0;            foreach (var s in a)            {                Thread.Sleep(100);  //模拟大量运算, 否则看不出效果                sum += s;            }            Console.WriteLine("ThreadID={0}, sum={1}",Thread.CurrentThread.ManagedThreadId,sum);        }

运行的结果是
ThreadID=3, sum=5
ThreadID=4, sum=26
按理正常结果应该是 15, 可以看出两个线程都分别干扰了对方的index

5.  由于IEnumerable<T>扩展（继承）了旧的IEnumerable接口，所以要实现两个不同的方法：
    IEnumerator<T> GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator; // 由于和泛型版本的方法同名，所以该方法的实现需要使用显式接口实现

6.  我们通过ILSpy 看看源码中 List 的IEnumerator定义

public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator{private List<T> list;private int index;private int version;private T current;[__DynamicallyInvokable]public T Current{[__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]get{return this.current;}}[__DynamicallyInvokable]object IEnumerator.Current{[__DynamicallyInvokable]get{if (this.index == 0 || this.index == this.list._size + 1){ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);}return this.Current;}}internal Enumerator(List<T> list){this.list = list;this.index = 0;this.version = list._version;this.current = default(T);}[__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]public void Dispose(){}[__DynamicallyInvokable]public bool MoveNext(){List<T> list = this.list;if (this.version == list._version && this.index < list._size){this.current = list._items[this.index];this.index++;return true;}return this.MoveNextRare();}private bool MoveNextRare(){if (this.version != this.list._version){ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);}this.index = this.list._size + 1;this.current = default(T);return false;}[__DynamicallyInvokable]void IEnumerator.Reset(){if (this.version != this.list._version){ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion);}this.index = 0;this.current = default(T);}}

后记: 我现在很疑惑非要实现这两个接口,  for (int i = 0; i < length; i++) 这种遍历方式的速度还要快些, 如果不是泛型, 比如int[]数组, 即便是用了foreach, 编译器也会优化成for循环, 那实现这两个接口仅仅是为了让别人用 foreach ?