几个月前我曾大致分析过 C# 2.0 中 iterator block 机制的实现原理，《C# 2.0 中Iterators的改进与实现原理浅析》，文中简要介绍了 C# 2.0 是如何在不修改 CLR 的前提下由编译器，通过有限状态机来实现 iterator block 中 yield 关键字。
实际上，这一机制的最终目的是提供一个代码协同执行的支持机制。
以下内容为程序代码:


using System.Collections.Generic;

public class Tokens : IEnumerable<string>
{
public IEnumerator<string> GetEnumerator()
{
for(int i = 0; i<elements.Length; i++)
yield elements[i];
}
...
}

foreach (string item in new Tokens())
{
Console.WriteLine(item);
}



在这段代码执行过程中，foreach 的循环体和 GetEnumerator 函数体实际上是在同一个线程中交替执行的。这是一种介于线程和顺序执行之间的协同执行模式，之所以称之为协同（Coroutine），是因为同时执行的多个代码块之间的调度是由逻辑隐式协同完成的。顺序执行无所谓并行性，而线程往往是由系统调度程序强制性抢先切换，相对来说Win3.x 中的独占式多任务倒是与协同模型比较类似。
就协同执行而言，从功能上可以分为行为、控制两部分，控制又可进一步细分为控制逻辑和控制状态。行为对应着如何处理目标对象，如上述代码中：行为就是将目标对象打印到控制台；控制则是如何遍历这个 elements 数组，可进一步细分为控制逻辑（顺序遍历）和控制状态（当前遍历到哪个元素）。下面将按照这个逻辑介绍不同语言中如何实现和模拟这些逻辑。

Spark Gray 在其 blog 上有一个系列文章介绍了协同执行的一些概念。

Iterators in Ruby (Part - 1)
Warming up to using Iterators (Part 2)

文章第 1, 2 部分以 Ruby 语言（语法类似 Python）介绍了 Iterator 机制是如何简化遍历操作的代码。实际上中心思想就是将行为与控制分离，由语言层面的支持来降低控制代码的薄记工作。
以下内容为程序代码:

def textfiles(dir)
Dir.chdir(dir)

Dir["*"].each do |entry|
yield dir+"\"+entry if /^.*.txt$/ =~ entry

if FileTest.directory?(entry)
textfiles(entry){|file| yield dir+"\"+file}
end
end
Dir.chdir(".."[img]/images/wink.gif[/img]
end

textfiles(“c:\”){|file|
puts file
}



例如上面这段 Ruby 的递归目录处理代码中，就采用了与 C# 2.0 中完全类似的语法实现协同执行支持。

对 C# 1.0 和 C++ 这类不支持协同执行的语言，协同执行过程中的状态迁移或者说执行绪的调度工作，需要由库和使用者自行实现，例如 STL 中的迭代器 (iterator) 自身必须保存了与遍历容器相关的位置信息。例如在 STL 中实现协同执行：
以下内容为程序代码:

#include <vector>
#include <algorithm>
#include <iostream>

// The function object multiplies an element by a Factor
template <class Type>
class MultValue
{
private:
Type Factor; // The value to multiply by
public:
// Constructor initializes the value to multiply by
MultValue ( const Type& _Val [img]/images/wink.gif[/img] : Factor ( _Val [img]/images/wink.gif[/img] {
}

// The function call for the element to be multiplied
void operator ( [img]/images/wink.gif[/img] ( Type& elem [img]/images/wink.gif[/img] const
{
elem *= Factor;
}
};

int main( [img]/images/wink.gif[/img]
{
using namespace std;

vector <int> v1;

//...

// Using for_each to multiply each element by a Factor
for_each ( v1.begin ( [img]/images/wink.gif[/img] , v1.end ( [img]/images/wink.gif[/img] , MultValue<int> ( -2 [img]/images/wink.gif[/img] [img]/images/wink.gif[/img];
}



虽然 STL 较为成功的通过迭代器、算法和谓词，将此协同执行逻辑中的行为和控制分离，谓词表现行为(MultValue<int>、迭代器(v1.being(), v1.end())表现控制状态、算法表现控制逻辑(for_each)，但仍然存在编写复杂，使用麻烦，并且语义不连冠的问题。
一个缓解的方法是将谓词的定义与控制部分合并到一起，就是类似 boost::Lambda 的实现思路：
以下内容为程序代码:

for_each(v.begin(), v.end(), _1 = 1);

for_each(vp.begin(), vp.end(), cout << *_1 << ' ');



通过神奇的模板和宏，可以一定程度降低编写独立谓词来定义行为的复杂度。但控制部分的状态和逻辑还是需要单独实现。

而 C# 1.0 中就干脆没有自带支持，必须通过《C# 2.0 中Iterators的改进与实现原理浅析》一文中所举例子那样笨拙的方式完成。
以下内容为程序代码:

public class Tokens : IEnumerable
{
public string[] elements;

Tokens(string source, char[] delimiters)
{
// Parse the string into tokens:
elements = source.Split(delimiters)