在第一篇文章中，我讨论了如何用IronPython来模拟C#的语言扩展。在这篇文章中，我将进一步讨论如何用IronPython来构造LINQ查询。如果您读过《LINQ in Action》，您会发现我是依据此书来组织本系列文章的。我的第一篇文章对应《LINQ in Action》的第2章“C#和VB的语言增强”，本文对应第3章“LINQ构建块”。
1. IEnumerable<T>
在意图上，LINQ to Objects旨在查询内存中的数据源；在技术上，这些数据源是实现了System.Collections.Generic.IEnumerable<T>接口的对象。C#程序员常常使用.NET Framework提供了泛型容器作为数据源对象，它们位于System.Collections.Generic名空间下并实现了IEnumerable<T>。那么，IronPython程序员经常使用Python标准容器，包括列表（list）、元组（tuple）、集合（set）和字典（dict），实现了IEnumerable<T>吗？在IronPython 2.x的命令行上运行如下语句，就可以知道答案。
>>> import System
>>> ie_object = System.Collections.Generic.IEnumerable[System.Object]
>>> isinstance(list(),ie_object)
True
>>> isinstance(tuple(), ie_object)
True
>>> isinstance(set(), ie_object)
True
>>> isinstance(dict(), ie_object)
False
由运行结果可知，list、tuple和set实现了IEnumerable<Object>，而dict没有实现。实际上，C#也面临相似的问题。在.NET Framework中存在大量没有实现IEnumerable<T>的非泛型容器，程序员也会实现自定义的容器。如何将这些容器方便地配接（adapt）到IEnumerable<T>呢？C#设计者给出的答案是迭代器。
2. 迭代器（Iterator）
迭代器是一个用于遍历集合元素的对象。由于这是一种非常有用的设计模式，.NET Framework提供了迭代器接口IEnumerable（以及相应的范型接口IEnumerable<T>），C#语言则提供了关键字yield，以便直接构造实现了IEnumerable的迭代器类型。利用迭代器，C#程序就可以将非泛型容器、自定义容器和序列配接到IEnumerable<T>上。例如，Enumerable为非泛型容器提供了扩展方法Cast，它的一种可能实现如下。
1: public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source)
2: {
3: foreach (object elem in source)
4: {
5: yield return (TResult)elem;
6: }
7: }
在该实现中，Cast利用foreach迭代非泛型容器，将其中的元素强制转换为目标类型TResult的对象，然后用yield构造出实现了IEnumerable<T>的迭代器。这段代码简单明了，也很容易应用到其他需要IEnumerable<T>的情景中。
与C#类似，Python提供了关键字yield用于生成迭代器。此外，Python还提供迭代器的另一种形式：生成器（Generator）。利用它们可以将IronPython中的dict和自定义序列配接到IEnumerable<T>。在IronPython 2.x的命令行上运行如下语句，可知yield和生成器所返回的对象都实现了IEnumerable<Object>。
1: >>> import System
2: >>> ie_object = System.Collections.Generic.IEnumerable[System.Object]
3: >>> def seq(num):
4: ... for i in range(num):
5: ... yield i
6: ...
7: >>> isinstance(seq(1), ie_object)
8: True
9: >>> isinstance((i for i in range(1)) # (i for i in range(1)) is a generator,
10: ... # whose result is the same with seq(1).
11: ... , ie_object)
12: True
3. 查询操作符（Query Operator）
LINQ to Objects的查询操作符是定义在System.Linq.Enumerable类中的扩展方法。其签名形如：
1: public static int Count<TSource>
2: (this IEnumerable<TSource> source);
3:
4: public static IEnumerable<TResult> Select<TSource, TResult>
5: (this IEnumerable<TSource> source, Func<TSource, TResult> selector);
6:
7: public static IEnumerable<TSource> Where<TSource>
8: (this IEnumerable<TSource> source, Func<TSource, bool> predicate);
由于它们都是泛型函数，IronPython在调用它们时必须指定TSource等类型参数的具体类型。Harry Peirson在他的IronPython and Linq to XML中提供了一组辅助函数来简化IronPython的调用代码。
1: def Count(col):
2: return Enumerable.Count[object](col）
3:
4: def Select(col, fun):
5: return Enumerable.Select[object, object](col, Func[object, object](fun))
6:
7: def Where(col, fun):
8: return Enumerable.Where[object](col, Func[object, bool](fun))
以辅助方法Where(col, fun)为例，它将Enumerable.Where的类型参数TSource指定为object（即System.Object），也就是将该函数的第一个参数具现为IEnumerable<Object>，这样就可以将IronPython中的容器和生成器传递给该参数。然后它把IronPython中的函子fun包装为System.Func的对象，并将该对象传递给Enumerable.Where的第二个参数。这样包装的原因是，Enumerable.Where只接受Func对象，而不接受IronPython定义的函数和lambda表达式。
有了这样一组辅助方法，我们就可在IronPython中调用LINQ to Objects了。例如，以下这条C#语句
int count = Process.GetProcesses()
.Where(process => process.WorkingSet64 > 20*1024*1024)
.Count();
就可以用IronPython实现为
processes = Process.GetProcesses()
processes = Where(processes, lambda p: p.WorkingSet64 > 20*1024*1024)
cnt = Count(processes)
4. 查询表达式（Query Expression）
查询表达式是C#编译器提供的用于简化查询代码的语法糖。C#编译器会将查询表达式翻译为对扩展方法的调用。例如查询表达式
var processes =
from process in Process.GetProcesses()
where where process.WorkingSet64 > 20*1024*1024
orderby process.WorkingSet64
select new { process.Id, Name = process.ProcessName };
会被翻译为
var processes =
Process.GetProcesses()
.Where(process => process.WorkingSet64 > 20 * 1024 * 1024)
.OrderBy(process => process.WorkingSet64)
.Select(process => new { process.Id, Name = process.ProcessName });
由于IronPython编译器不支持查询表达式，在IronPython中无法写出SQL-Like的查询语句。但是，利用powershell.py（在IronPython自带的Tutorial目录下可以找到该文件）所提供的思路，我们可以写出“流水线”风格的查询。
processes = (
From(Process.GetProcesses())
.Where(lambda p: p.WorkingSet64 > 20*1024*1024)
.OrderBy(lambda p: p.WorkingSet64)
.Select(lambda p: makeobj(Id = p.Id, Name = p.ProcessName))
)
流水线是一种非常有用的“隐喻”，在Unix Shell、Windows PowerShell等环境中得到广泛的使用。程序员们熟悉它、喜爱它。更重要的是，它符合LINQ流式供应、延迟求值（deferred evaluation）的特点。从某种角度，它比查询表达式更好地表现了查询操作的语义。
在本系列的第三篇文章中，我将基于已有的讨论给出完整的解决方案，在IronPython中提供流水线风格的LINQ to Objects查询。