IEnumerable实践应用

1.集合想要支持foreach方式遍历，需要返回一个迭代器（IEnumerator），foreach会自动调用迭代器的状态迁移(MoveNext()、Curent、Reset())

#region Assembly mscorlib.dll, v4.0.0.0
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion

using System;
using System.Runtime.InteropServices;

namespace System.Collections
{
    // Summary:
    //     Supports a simple iteration over a nongeneric collection.
    [ComVisible(true)]
    [Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
    public interface IEnumerator
    {
        object Current { get; }

        bool MoveNext();

        void Reset();
    }
}

2.IEnumerable接口定制了foreach的需求

#region Assembly mscorlib.dll, v4.0.0.0
// C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\mscorlib.dll
#endregion

using System.Runtime.InteropServices;

namespace System.Collections
{
    // Summary:
    //     Exposes the enumerator, which supports a simple iteration over a non-generic
    //     collection.
    [ComVisible(true)]
    [Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
    public interface IEnumerable
    {
        [DispId(-)]
        IEnumerator GetEnumerator();
    }
}

3.类似于List的列表定义如下：

    /// <summary>
    /// 列表
    /// </summary>
    class MyList : ArrayList, IEnumerable<object>
    {

        // 迭代器返回  
        public IEnumerator<object> GetEnumerator()
        {
            return new MyListEnumerator(this);
        }

        /// <summary>
        /// 1.由于IEnumerable<T>继承自IEnumerable，因此必须实现其方法
        /// 2.由于已经存在同名方法，因此需要显示实现
        /// </summary>
        /// <returns></returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            //return GetEnumerator(); // IEnumerator是IEnumerator<T>的基类  
            return null;
        }
    }

    /// <summary>
    /// 为列表定制的迭代器
    /// </summary>
    class MyListEnumerator : IEnumerator<object>
    {
        private int current = -;
        private MyList _mylist;

        public MyListEnumerator(MyList mylist)
        {
            _mylist = mylist;
            current = _mylist == null || _mylist.Count ==  ? - : ;
        }

        public bool MoveNext()
        {
            current++;
            return _mylist != null && _mylist.Count > current;
        }

        object IEnumerator<object>.Current
        {
            get
            {
                if (_mylist != null && _mylist.Count > current) return _mylist[current];
                return null;
            }
        }
        // 1.由于IEnumerable<out T>继承自IEnumerable，因此必须实现其方法
        // 2.由于已经存在同名方法，因此需要显示实现
        object IEnumerator.Current
        {
            get
            {
                //if (_mylist != null && _mylist.Count > current)return _mylist[current];
                return null;
            }
        }

        public void Reset()
        {
            current = _mylist == null || _mylist.Count ==  ? - : ;
        }

        // IEnumerator<T>继承了IDisposable，为了遍历完后清理状态，所以需要实现该方法  
        // 该方法在foreach循环完毕后自动调用  
        public void Dispose() { }
    }

4.IEnumerator作为迭代器，源于底层编程语言指针的启发；

引用类型不同于值类型的一个重要特点就是用到的时候才会进行真正的处理；

.Net中yield关键字对此有很好的支持，以下举例说明：

       static void Main(string[] args)
        {
            var list = GetStrings();
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }

            list = GetStrings();
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }

            Console.ReadLine();
        }
运行结果：aaarticlea/png;base64,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" alt="" />

        /// <summary>
        /// 1.yield return将单次运算结果放入IEnumerable集合中
        /// 2.yield break中断当前迭代器的作用域
        /// </summary>
        /// <param name="length"></param>
        /// <returns></returns>
        public static IEnumerable<string> GetStrings(int length = )
        {
            for (int i = ; i < length; i++)
            {
                if (i < )
                {
                    yield return string.Format("第{0}次调用", i);
                }
                else
                {
                    yield break;
                }
            }
            Console.WriteLine("yield break之后在迭代作用域内的代码不会再被执行");
        }

补充：上面GetStrings传统上很多人习惯如下写法，但是这样做的时间开销是n*m，其中n为待运算列表长度，m为第一次遍历长度，这就是为什么上面强调用到的时候才会进行真正的处理

 public static List<string> GetStrings(int length = )
        {
            var result = new List<string>();
            for (int i = ; i < length; i++)
            {
                if (i < )
                {
                    result.Add(string.Format("第{0}次调用", i));
                }
            }
            return result;
        }