C# in depth （第六章 实现迭代器的捷径）

迭代器模式是行为模式的一种范例，行为模式是一种简化对象之间通信的设计模式。这是一种非常易于理解和使用的模式。实际上，它允许你访问一个数据项序列中的所有元素，而无须关心序列是什么类型----数组，列表，链表或任何其他类型。它能非常有效地构建出一个数据管道，经过一系列不同的转换或过滤后再从管道的另一端出来。实际上，这也是LINQ的核心模式之一。

可以将迭代器想象成数据库的游标，即序列中的某个位置。迭代器只能在序列中向前移动，而且对于同一个序列可能同时存在多个迭代器操作。

6.1 C#1.0：手写迭代器的痛苦

class IterationSample : IEnumerable
{
object[] values;
int startingPoint;

public IterationSample(object[] values, int startingPoint)
{
this.values = values;
this.startingPoint = startingPoint;
}

public IEnumerator GetEnumerator()
{
return new IterationSampleIterator(this);
}

class IterationSampleIterator : IEnumerator
{
IterationSample parent;    //1.正在迭代的集合
int position;              //2.指出遍历到的位置

internal IterationSampleIterator(IterationSample parent)
{
this.parent = parent;
position = -1;        //3.在第一个元素之前开始
}

public bool MoveNext()
{
if (position != parent.values.Length)//4.如果仍要遍历，那么增加position的值
{
position++;
}
return position < parent.values.Length;
}

public object Current
{
get
{
if (position == -1 ||
position == parent.values.Length)//5.防止访问第一个元素之前和最后一个元素之后
{
throw new InvalidOperationException();
}
int index = (position + parent.startingPoint); //6.实现封装
index = index % parent.values.Length;
return parent.values[index];
}
}

public void Reset()
{
position = -1;              //7.返回第一个元素之前
}
}

static void Main()
{
object[] values = { "a", "b", "c", "d", "e" };
IterationSample collection = new IterationSample(values, 3);
foreach (object x in collection)
{
Console.WriteLine(x);
}
}
}

首先要知道，我们需要在某个地方存储某个状态。迭代器模式的一个重要方面就是，不用一次返回所有数据----调用代码一次只需获取一个元素。这意味着我们需要确定访问到了数组中的哪个位置。在了解C#2.0编译器为我们所做的事情时，迭代器的这种状态特制十分重要，因此，要密切关注本例中的状态。

我们要记住迭代的原始值的集合 1

并用简单的从零开始的数组跟踪我们所在的位置 2

为了返回元素，要根据原始点对索引进行偏移。6

要让迭代器逻辑上从第一个元素的位置之前开始 3

所以在第一次使用Current属性之前，调用代码必须调用MoveNext方法。4 中的条件增量可以保证 5中的条件判断简单准确，即使在程序第一次报告无可用数据后又调用MoveNext也没有问题。

为了重置迭代器，我们将我们的逻辑位置设置回"第一个元素之前“ 7

6.2.1 迭代器和yield return 简介

class IteratorBlockIterationSample : IEnumerable
{
object[] values;
int startingPoint;

public IteratorBlockIterationSample(object[] values, int startingPoint)
{
this.values = values;
this.startingPoint = startingPoint;
}

public IEnumerator GetEnumerator()
{
for (int index = 0; index < values.Length; index++)
{
yield return values[(index + startingPoint) % values.Length]; //完全替换掉了整个IterationSampleIterat
}
}

static void Main()
{
object[] values = { "a", "b", "c", "d", "e" };
IteratorBlockIterationSample collection = new IteratorBlockIterationSample(values, 3);
foreach (object x in collection)
{
Console.WriteLine(x);
}
}
}

这个方法不是一个普通的方法，而是实现一个迭代器块的方法。这个方法被声明为返回一个IEnumerator接口。

当编译器看到迭代器块时，会为状态机创建一个嵌套类型，来正确记录块中的位置以及局部变量（包括参数）的值。所创建的类类似于我们之前用普通方法实现的类，用实例变量来保存所有必要的状态。下面来看一下，要实现迭代器，这个状态机要做哪些事情：

它必须具有某个初始状态:

每次调用MoveNext时，在提供下一个值之前（换句话说，就是执行到yield return 语句之前），它需要执行GetEnumerator方法中的代码

使用Current属性时，它必须返回我们生成的上一个值。

它必须知道何时完成生成值的操作，以便MoveNext返回False。

6.2.2 观察迭代器的工作流程

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

static IEnumerable<int> CreateEnumerable()
{
Console.WriteLine("{0}Start of CreateEnumerable()", 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", Padding);
}

Console.WriteLine("{0}Yielding final value", Padding);
yield return -1;

Console.WriteLine("{0}End of GetEnumerator()", Padding);
}

static void Main()
{
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);
}
}
}

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

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

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

在一个方法中的不同地方可以编写多个yield return语句;

代码不会在最后的yield return处结束,而是通过返回false的MoveNext调用结束来结束方法的执行。

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

使用yield break结束迭代器的执行 (如果你希望”提早退出“，那么yield break 正是你所需要的。它实际上终止了迭代器的运行，让当前对MoveNex的调用返回false。

class YieldBreak
{
static IEnumerable<int> CountWithTimeLimit(DateTime limit)
{
for (int i = 1; i <= 100; i++)
{
if (DateTime.Now >= limit)
{
yield break;
}
yield return i;
}
}

static void Main()
{
DateTime stop = DateTime.Now.AddSeconds(2);
foreach (int i in CountWithTimeLimit(stop))
{
Console.WriteLine("Received {0}", i);
Thread.Sleep(300);
}
}
}

2. finally 代码块的执行

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

static void Main()
{
DateTime stop = DateTime.Now.AddSeconds(2);
foreach (int i in CountWithTimeLimit(stop))
{
Console.WriteLine("Received {0}", i);
Thread.Sleep(300);
}
}

finally会在yield break之后执行

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

static void Main()
{
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);
}
}

finally会在Main函数里的return之后执行；只要调用者使用了foreach循环,迭代器块中的finally将按照你期望的方式工作。

6.2.4具体实现中的奇特之处

6.3 真实的迭代器示例

6.3.1迭代时刻表中的日期

for (DateTime day = timetable.StartDate; day <= timetable.EndDate; day= day.AddDays(1))
{

}

public IEnumerable<DateTime> DateRange
{
get
{
for(DateTime day = StartDate;
day<=EndDate;
day =day.AddDays(1))
{
yield return day;
}
}
}

6.3.2 迭代文件中的行

class LineReader
{
public static IEnumerable<string> ReadLines(string filename)
{
using (TextReader reader = File.OpenText(filename))
{
string line;
while ((line = reader.ReadLine()) != null)
{
yield return line;
}
}
}

static void Main()
{
foreach (string line in ReadLines("../../LineReader.cs"))
{
Console.WriteLine(line);
}
}
}

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

class FakeLinq
{
public static IEnumerable<T> Where<T>(IEnumerable<T> source, Predicate<T> predicate)
{
if (source == null || predicate == null)//1.热情的检查参数
{
throw new ArgumentNullException();
}
return WhereImpl(source, predicate);  //2.懒惰地（延时）处理数据
}

private static IEnumerable<T> WhereImpl<T>(IEnumerable<T> source, Predicate<T> predicate)
{
foreach (T item in source)
{
if (predicate(item)) //3.检查当前项与谓词是否匹配
{
yield return item;
}
}
}

static void Main()
{
IEnumerable<string> lines = LineReader.ReadLines("../../FakeLinq.cs");
Predicate<string> predicate = delegate(string line)
{ return line.StartsWith("using"); };
foreach (string line in Where(lines, predicate))
{
Console.WriteLine(line);
}
}
}

假设将所有的内容都放入同一个方法中，那么调用Where<string>(null,null)时会发生什么呢？ 答案是什么也不发生，或至少不会抛出我们认为的异常。这是由迭代器块的延迟语义所决定的。因为在第一次调用MoveNext()之前，不会执行方法体内的任何代码。所以是像代码清单6-9中那样将方法一分为二。

首先在普通方法中检查参数 1.

然后调用使用迭代器块实现的方法，在得到请求时再延时处理数据2.

迭代器块本身十分简单：对于原始集合中的每一项，我们测试谓词3.