CSharpThinking---迭代器（三）

 

　　本章主要学习迭代器的相关内容，以便对Linq更好的理解。其中涉及两个比较重要的类IEnumerator和IEnumerable，这些类是扩展方法及Linq的基础，具体详情请参考MSDN。

　　迭代器是行为模式的一种范例，而行为模式是一种简化对象之间通信的设计模式。它允许你一个数据项列表中的所有元素，而无需关心序列是什么类型---数组，列表，链表等。它能

非常有效的构建出一个数据管道，数据项由此进入管道，并以不同的变换方式来遍历这些数据，或者在访问到末端之前进行一些过滤操作，事实上，这也是Linq核心模式的一种。

 

　　一，迭代器重要概念

　　　　1.1 如果一个类实现了IEnumerable接口，则它就可以被迭代器访问，称为可迭代，调用GetEnumerator返回IEnumerator，这就是迭代器本身，相当于数据库的游标。

　　　　1.2 C#1中不能试用yield return 。而C#2中实现了 yield return模式，大大简化构建一个迭代器。

 

　　二，迭代器工作流程

　　　　2.1 手动实现yield return，工作流程展示。

        static readonly string Padding = new string(' ', 30);

        static IEnumerable<int> CreateEnumerable() 
        {
            Console.WriteLine("{0} start of CreatEnumerable()",Padding);

            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("{0} About to yield {1}", Padding, i);
                yield return i;
                Console.WriteLine("{0} After yield return",Padding);
            }
            Console.WriteLine("{0} Yielding final value",Padding);
            yield return -1;
            Console.WriteLine("{0} End of CreatEnumerable()", Padding);
        }

        public void TestMain() 
        {
            IEnumerable<int> iterable = CreateEnumerable();
            IEnumerator<int> iterator = iterable.GetEnumerator();

            Console.WriteLine("Starting to iterate");
            while (true)
            {
                Console.WriteLine("Calling MoveNext()...");
                bool result = iterator.MoveNext();
                Console.WriteLine("...MoveNext result={0}",result);
                if (!result) 
                {
                    break;
                }
                Console.WriteLine("Fetching Current...");
                Console.WriteLine("...Current result = {0}",iterator.Current);
            }
        }

  　　  结果：

　　　　以上结果说明问题：

　　  　　1. 在第一次调用MoveNext之前，CreateEnumerable中的代码不会被调用。

　　  　　2. 所有工作都在调用MoveNext的时候就完成了，获取Current值不会执行任何代码；

　　  　　3. 在yield return的位置，代码就停止执行，在下一次调用MoveNext的时候又继续执行；

　　  　　4. 在一个方法中的不同地方可以书写多个yield return语句；

　　　　  5. 代码不会在最后的yield return出结束---相反，而是通过返回false的MoveNext调用来借宿方法的执行。

 　　

　　　　2.2 与try/finally一起使用的yield break

 　　　　 2.2.1 使用yield break不会像yield return一样，看上去退出了循环。

　　　 　 2.2.2 如果使用foreach循环调用迭代器成员，则最后会隐式执行Dispose（），导致最终会执行finally，代码如下：

        static IEnumerable<int> CountWithTimeLimit(DateTime dt)
        {
            try
            {
                for (int i = 0; i < 100; i++)
                {
                    if (DateTime.Now >= dt)
                        yield break;
                    yield return i;
                }
            }
            finally
            {
                Console.WriteLine("Stopping...");
            }
        }

        void TestMain2()
        {
            DateTime stop = DateTime.Now.AddSeconds(2);
            foreach (int i in CountWithTimeLimit(stop))
            {
                Console.WriteLine("Received {0} ", i);
                if (i > 3)
                {
                    Console.WriteLine("Returning...");
                    return;
                }
                Thread.Sleep(300);
            }
        }

        /* Result:
         *  Received 1
         *  Received 2
         *  Received 3
         *  Received 4
         *  Returning...
         *  Stropping...
         *  */

　

　　三， 迭代器例子

　　　　3.1 C#2 例子

        /// <summary>
        ///  C#2.0 迭代器应用
        /// </summary>
        /// <remarks>
        /// 封装内部方法
        /// </remarks>
        /// <param name="provider"></param>
        /// <returns></returns>
        static IEnumerable<string> ReadLines(Func<TextReader> provider)
        {
            using (TextReader tr = provider())
            {
                string line;
                while ((line = tr.ReadLine()) != null)
                {
                    yield return line;
                }
            }
        }
        /// <summary>
        /// 重载ReadLines
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        static IEnumerable<string> ReadLines(string filename, Encoding encoding)
        {
            return ReadLines(delegate { return new StreamReader(filename, encoding); });
        }
        /// <summary>
        /// 测试代码
        /// </summary>
        void TestMain3()
        {
            foreach (string line in ReadLines("text.txt", Encoding.Default))
            {
                Console.WriteLine(line);
            }
        }

　　　　3.2 由于迭代器的延迟特性，如果想在调用之前检查代码，如下所示：（上文中的MoveNext之前是不会执行任何代码的）

        /// <summary>
        /// 外部公开方法:先检查，然后调用私有方法执行（延迟执行）方法。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public static IEnumerable<T> where<T>(IEnumerable<T> source, Predicate<T> predicate)
        {
            if (source == null || predicate == null)
                throw new ArgumentNullException();
            return WhereImpl(source, predicate);
        }

        private static IEnumerable<T> WhereImpl<T>(IEnumerable<T> source, Predicate<T> predicate)
        {
            foreach (T item in source)
            {
                if (predicate(item))
                    yield return item;
            }
        }

　　　　3.3 CCR实现伪同步代码：核心思想调用迭代器中的yield return

　　　　 这种用法的核心思想是状态机：异步开发中两个复杂的问题就是处理状态和在感兴趣的事情发生之前进行有效的暂停。迭代器块使这两个问题得以完美的解决。