6.2 C# 2：利用 yield 语句简化迭代器

     class Program
     {
         static void Main(string[] args)
         {
             object[] values = new object[] { "a", "b", "c", "d", "e" };
             IterationSample sample = new IterationSample(values, );
             foreach (var item in sample)
             {
                 Console.WriteLine(item);
             }
             Console.ReadKey();
         }
     }
     public class IterationSample : IEnumerable
     {
         public object[] values;
         int startPoint;
         public IterationSample(object[] values, int startingPoint)
         {
             this.values = values;
             this.startPoint = startingPoint;
         }
         public IEnumerator GetEnumerator()
         {
             //return new IterationSampleIterator(this);
             for (int index = ; index < values.Length; index++)
             {
                 yield return values[(index + startPoint) % values.Length];
             }
         }
     }
     public class IterationSampleIterator : IEnumerator
     {
         IterationSample parent;
         int position;
         public IterationSampleIterator(IterationSample parent)
         {
             this.parent = parent;
             this.position = -;
         }
         public object Current
         {
             get
             {
                 if (position == - || position == parent.values.Length)
                 {
                     throw new InvalidOperationException();
                 }
                 int index = position + parent.values.Length;
                 index = index % parent.values.Length;
                 return parent.values[index];
             }
         }

         public bool MoveNext()
         {
             if (position != parent.values.Length)
             {
                 position++;
             }
             return position < parent.values.Length;
         }

         public void Reset()
         {
             position = -;
         }
     }

6.2.2 观察迭代器的工作流程

     class Program
     {
         static readonly string Padding = new string(' ', );
         static void Main(string[] args)
         {
             IEnumerable<int> iterable = CreatteEnumerable(Padding);
             IEnumerator<int> iterator = iterable.GetEnumerator();
             Console.WriteLine("starting iterate");

             while (true)
             {
                 Console.WriteLine("=======================================");
                 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);
             }

             Console.ReadKey();
         }
         static IEnumerable<int> CreatteEnumerable(string Padding)
         {
             Console.WriteLine("{0} start of createEnumerbale padding", Padding);

             for (int i = ; i < ; i++)
             {
                 Console.WriteLine("{0} about to yield {1}", Padding, i);
                 yield return i;
                 Console.WriteLine("{0} after padding", Padding);
             }
             Console.WriteLine("{0} yield final value ", Padding);
             yield return -;
             Console.WriteLine("{0} end of createEnumerable();", Padding);
         }
         /*

         starting iterate
         =======================================
         calling MoveNext()
                                        start of createEnumerbale padding
                                        about to yield 0
         moveNext result = True
         fetching current
         current result = 0
         =======================================
         calling MoveNext()
                                        after padding
                                        about to yield 1
         moveNext result = True
         fetching current
         current result = 1
         =======================================
         calling MoveNext()
                                        after padding
                                        about to yield 2
         moveNext result = True
         fetching current
         current result = 2
         =======================================
         calling MoveNext()
                                        after padding
                                        yield final value
         moveNext result = True
         fetching current
         current result = -1
         =======================================
         calling MoveNext()
                                        end of createEnumerable();
         moveNext result = False

          */
     }

 6.2.3 进一步了解迭代器执行流程

1. 使用 yield break 结束迭代器的执行

     class Program
     {
         static void Main(string[] args)
         {
             DateTime stop = DateTime.Now.AddSeconds();
             foreach (var item in CountWithTimeLimit(stop))
             {
                 Console.WriteLine("received {0}", item);
                 Thread.Sleep();
             }
             Console.ReadKey();
         }
         static IEnumerable<int> CountWithTimeLimit(DateTime limit)
         {
             for (int i = ; i < ; i++)
             {
                 if (DateTime.Now >= limit)
                 {
                     yield break;
                 }
                 yield return i;
             }
         }
     }

2.  finally 代码块的执行

     class Program
     {
         static void Main(string[] args)
         {
             DateTime stop = DateTime.Now.AddSeconds();
             foreach (var item in CountWithTimeLimit(stop))
             {
                 Console.WriteLine("received {0}", item);
                 if (item > )
                 {
                     Console.WriteLine("returning");
                     return;
                 }
                 Thread.Sleep();
             }
             Console.ReadKey();
         }
         static IEnumerable<int> CountWithTimeLimit(DateTime limit)
         {
             try
             {
                 for (int i = ; i < ; i++)
                 {
                     if (DateTime.Now >= limit)
                     {
                         yield break;
                     }
                     yield return i;
                 }
             }
             finally
             {
                 Console.WriteLine("stopping");
                 Console.ReadKey();
             }
         }
         /*
         received 0
         received 1
         received 2
         received 3
         received 4
         returning
         stopping
          */
     }

foreach 会在它自己的 finally 代码块中调用 IEnumerator 所提供的Dispose 方法（就像 using 语句）。
当迭代器完成迭代之前，你如果调用由迭代器代码块创建的迭代器上的 Dispose ，
那么状态机就会执行在代码当前“暂停”位置范围内的任何 finally 代码块。
这个解释复杂且有点详细，但结果却很容易描述：只要调用者使用了 foreach 循环，迭代器块中的 finally 将按照你期望的方式工作。

     class Program
     {
         static void Main(string[] args)
         {
             DateTime stop = DateTime.Now.AddSeconds();
             IEnumerable<int> iterable = CountWithTimeLimit(stop);
             IEnumerator<int> iterator = iterable.GetEnumerator();

             iterator.MoveNext();
             Console.WriteLine("received {0}", iterator.Current);

             iterator.MoveNext();
             Console.WriteLine("received {0}", iterator.Current);

             Console.ReadKey();
         }
         static IEnumerable<int> CountWithTimeLimit(DateTime limit)
         {
             try
             {
                 for (int i = ; i < ; i++)
                 {
                     if (DateTime.Now >= limit)
                     {
                         yield break;
                     }
                     yield return i;
                 }
             }
             finally
             {
                 Console.WriteLine("stopping");
                 Console.ReadKey();
             }
         }
         /*
         received 0
         received 1
          */
     }

幸好，作为开发人员我们不需要太关心编译器是如何解决这些问题的。不过，关于实现中的以下一些奇特之处还是值得了解的：
 在第一次调用 MoveNext 之前， Current 属性总是返回迭代器产生类型的默认值；
 在 MoveNext 返回 false 之后， Current 属性总是返回最后的生成值；
 Reset 总是抛出异常，而不像我们手动实现的重置过程那样，为了遵循语言规范，这是必要的行为；
 嵌套类总是实现 IEnumerator 的泛型形式和非泛型形式（提供给泛型和非泛型的IEnumerable 所用）。

6.3.2 迭代文件中的行

     class Program
     {
         static void Main(string[] args)
         {
             string fileName = string.Format(@"{0}aaa.txt", AppDomain.CurrentDomain.BaseDirectory);
             foreach (var item in ReadLines(fileName))
             {
                 Console.WriteLine(item);
             }

             Console.ReadKey();
         }
         static IEnumerable<string> ReadLines(string fileName)
         {
             using (TextReader reader = File.OpenText(fileName))
             {
                 string line;
                 while ((line = reader.ReadLine()) != null)
                 {
                     yield return line;
                 }
             }
         }
     }

 6.3.3 使用迭代器块和谓词对项进行延迟过滤

     class Program
     {
         static void Main(string[] args)
         {
             string fileName = string.Format(@"{0}aaa.txt", AppDomain.CurrentDomain.BaseDirectory);

             IEnumerable<string> lines = ReadLines(fileName);
             Predicate<string> predicate = line => line.StartsWith("using");

             foreach (var item in Where(lines, predicate))
             {
                 Console.WriteLine(item);
             }

             Console.ReadKey();
         }
         public static IEnumerable<T> Where<T>(IEnumerable<T> source, Predicate<T> predicate)
         {
             if (source.IsNull() || predicate.IsNull())
                 throw new ArgumentException();

             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;
                 }
             }
         }
         static IEnumerable<string> ReadLines(string fileName)
         {
             return ReadLines(() => { return File.OpenText(fileName); });
         }
         static IEnumerable<string> ReadLines(Func<TextReader> provider)
         {
             using (TextReader reader = provider())
             {
                 string line;
                 while ((line = reader.ReadLine()) != null)
                 {
                     yield return line;
                 }
             }
         }
     }