- 序列
- 延迟查询执行
- 查询操作符
- 查询表达式
- 表达式树
(一) 序列
先上一段代码,
这段代码使用扩展方法实现下面的要求:
- 取进程列表，进行过滤(取大于１０Ｍ的进程)
- 列表进行排序(按内存占用)
- 只保留列表中指定的信息(ＩＤ，进程名)
var res = Process.GetProcesses()
.Where(s => s.WorkingSet64 > * * )
.OrderByDescending(s => s.WorkingSet64)
.Select(s => new { ID = s.Id, Name = s.ProcessName });
为了能清楚理解上面代码的内部动作,我们需要介绍几组概念.
1. IEnumerable<T>接口
Process.GetProcesses()的返回值是一个Process的数组,而在C#中,所有数组对象均实现了IEnumerable<T>接口.
IEnumerable<T>接口之所以重要,是因为 上面代码中的Where, OrderByDescending, Select 等LINQ中的标准查询操作符都需要使用该类型的对象做为参数.
那么,上面代码中的Where, OrderByDescending, Select 是哪里来的呢? 它们是扩展方法, 基于IEnumerable<T>接口类型的扩展方法.
在LINQ中, 术语"序列" 就是指所有实现了IEnumerable<T>接口的对象.
我们给出Where扩展方法的实现代码:
public static IEnumerable<TSource> Where<TSource>(
this IEnumerable<TSource> source,
Func<TSource, Boolean> predicate)
{
foreach (TSource element in source)
{
if (predicate(element))
yield return element;
}
}
其第一参数中的this关键字就证明了它是一个扩展方法，参数类型就是IEnumerable<T＞．
关键字yield return 就构成了一个迭代器．
我们来看一下迭代器的背景知识．
２. 迭代器
从结果的角度看，迭代器与一个返回集合数据的传统方法没有什么区别，因为都是返回按一序列排列的值．
比如下面的代码，就返回一个集合的值．
int[] OneTwoThree()
{
return new[] { , , };
}
不过，Ｃ＃中的迭代器的行为却非常特殊．迭代器将不会一次性返回整个集合中的所有值．而是每次返回一个．这样的设计减少了内存需求．
我们构建一个迭代器的例子，看一看这个特性．
private void button2_Click(object sender, EventArgs e)
{
foreach (var m in OneTwoThree())
{
Console.WriteLine(m);
}
}
static IEnumerable<int> OneTwoThree()
{
Console.WriteLine("returning 1");
yield return ;
Console.WriteLine("returning 2");
yield return ;
Console.WriteLine("returning 3");
yield return ;
}
运行结果如下图
可以看到，函数OneTwoThree直到执行完最后一条语句之后才完整退出．
每次遇到yield return语句时，该方法都向调用者返回一个值．
foreach循环收到这个值后进行了处理，然后控制权又交回给迭代器方法OneTwoThree方法，由它给出下一个元素．
看起来好像两个方法在同时运行．这也正是可以将.NET中的迭代器当作是一类轻量级的协同程序(coroutine)的原因．
(二) 延迟查询执行
LINQ查询语句非常依赖于延迟查询执行机制，惹是缺少了这个机制，LINQ的执行效率将会大大降低．
来看一段代码：
static double Square(double n)
{
Console.WriteLine("计算 Square(" + n + ")...");
return Math.Pow(n, );
}
private void button3_Click(object sender, EventArgs e)
{
int[] numbers = { , , };
var res = from n in numbers
select Square(n);
foreach (var m in res)
Console.WriteLine(m);
}
运行结果如下：
结果可以看到，明显该查询并不是一次性执行完毕的．只有在迭代到某一项时，查询才开始求出这一项的值．
这就是所谓的查询延迟执行的机制在发挥作用．
我们来讨论一下其中的原理：
var res = from n in numbers
select Square(n);
上面的LINQ查询在编译后，实际上变成了这样的：
IEnumerable<double> res = Enumerable.Select<int, double>(numbers, n => Square(n));
也就是LINQ查询转为一系列扩展方法的调用，其中的Enumerable.Select方法正是一个迭代器－－这也就是其实现了延迟执行的原理．
如果我们需要查询强制立即执行，可以通过调用ToList方法来实现．
我们把上面的代码改动一下：
private void button4_Click(object sender, EventArgs e)
{
int[] numbers = { , , };
var res = from n in numbers
select Square(n);
foreach (var m in res.ToList())
Console.WriteLine(m);
}
可以看到结果就不同了：
可以见到是先得到查询的结果，最后才把结果迭代输出的．
(三) 查询操作符
上面代码所示的 Where,OrderByDescending, Select这些扩展方法 包含有共同的特性：
- 操作于可被迭代的集合对象之上
- 允许管道形式的数据处理
- 依赖于延迟执行
正是上面这些特征让这些扩展方法能用于编写查询．因此这些扩展方法也称为"查询操作符"
查询操作符是LINQ的核心，甚至比语言方面的特性(比如查询表达式)更重要．
下图是按照操作类型分组的标准查询操作符：
(四) 查询表达式
开往篇的程序是使用查询操作符实现的．再次引用一下：
var res = Process.GetProcesses()
.Where(s => s.WorkingSet64 > * * )
.OrderByDescending(s => s.WorkingSet64)
.Select(s => new { ID = s.Id, Name = s.ProcessName });
另一种语法则让LINQ查询更像是SQL的查询语句．
var res = from s in Process.GetProcesses()
where s.WorkingSet64 > * *
orderby s.WorkingSet64 descending
select new { ID = s.Id, Name = s.ProcessName };
上面的这种写法就叫做查询表达式，或者查询式语法．
这两种代码的写法从语义上来讲是完全相同的，而且实现的功能也一致．
查询表达式是由C#语言提供的语言级特性，一种语法糖，这种语法类似于SQL，它可以操作于一个或者多个数据源之上，并为这些数据源应用若干个标准或者自定义的查询操作符．在上面的示例代码中，使用了３个标准的查询操作符：Where, orderByDescending以及Select.
在使用查询表达式语法时，编译器会自动将其转化为对标准查询操作符的调用．
查询表达式存在的最主要意义在于，它能够大大简化查询所需要的代码，并提高查询语句的可读性(类似熟悉的SQL)．
下图是查询表达式的完整语法：
标准查询操作符与查询表达式的关系，见下表所示：
通过上表可以看到，不是每一个操作符都有与之对应的C#关键字．在前面那个简单的查询中，我们当然完全可以使用语言所提供的关键字实现．不过对于那些较为复杂的查询来说，我们将不得不直接调用查询操作符完成．
因为查询表达式最终都会被编译成各个标准操作符的调用．因此如果愿意的话，完全可以只用查询操作符编写所有查询语句，根本不理会查询表达式的存在．
(五) 表达式树
Lambda表达式在前面提到过它的主要作用之一是实现匿名委托．如下例：
Func<int,bool> isOdd=i=>(i & )==;
但是，Lambda表达式也能够以数据的形式使用，这正是表达式树所要求的．
当把代码改成下面这样时，我们就无法以委托的形式来使用isOdd了．因为在这里isOdd并不是委托，而是个表达式树．
Expression<Func<int,bool>> isOdd =i => (i & ) ==;
编译器不会把上面的Lambda表达式换成IL代码，而是会构造出一个树状的，用来表示该表达式的对象．
但是需要注意的是：只有那些带有表达式体的Lambda表达式才能够用于表达式树．主体部分是语句的Lambda表达式则没有类似的支持．
例如，下面第１行代码可以用来生成一颗表达式树，因为其带有表达式体．
第２行的就不能，因为它的主体部分是一个语句．
Expression<Func<Object, Object>> identity = o=>o;
Expression<Func<Object, Object>> identity = o=>{ return o;};
当编译器看到某个Lambda表达式赋值给类型为Expression<>的变量时，就会将其编译成一系列工厂方法的调用，这些工厂方法将在程序运行时动态地构造出表达式树．
下面就是编译器为上述表达式自动生成的代码：
ParameterExpression i = Expression.Parameter(typeof(int), "i");
Expression<Func<int, bool>> isOdd =
Expression.Lambda<Func<int, bool>>(
Expression.Equal(
Expression.And(
i,
Expression.Constant(, typeof(int))),
Expression.Constant(, typeof(int))),
new ParameterExpression[] { i });
上面的代码是可以手工编写的，但是编译器可以代劳．
表达式树将在程序运行中动态构造，不过一旦构造完成，则无法被再次修改．
表达式树在第５章中用以创建动态查询这种高级场景上得到了应用．
上面的表达式树，在内存中以树的数据结构存储，它表示解析了后的Lambda表达式，如下图：
上面的表达式树，还可以"逆向"编译成委托方法：
Expression<Func<int, bool>> isOddExpression = i => (i & ) == ;
Func<int, bool> isOddCompiledExpression = isOddExpression.Compile();
这时候，上面的isOddCompiledExpression和下面的委托isOdd就完全相同了，它们生成的IL代码就没有任何区别了．
Func<int,bool> isOdd=i=>(i & )==;
为什么要使用表达式树呢？
实际上，表达式树就是一颗抽象语法树(AST)．抽象语法树用来表示一段经过解析的代码．在上面例子中，这颗树就是C#对于Lambda表达式解析后的结果．这样做的目的是便于其它代码对该表达式树进行分析，并执行一些必要的操作．
表达式树可以在运行时传递给其它的工具，随后这些工具可以根据该树开始执行查询，或者是将其转化为其它形式的代码，例如LINQ to SQL中的SQL语句．
最后我们来看看表达式树执行延迟查询执行的方法：
引用之前LINQ to SQL例子中的代码：
var contacts =
from contact in db.GetTable<HelloLinqToSql.Contact>()
where contact.City == "武汉"
select contact; Console.WriteLine("查找在武汉的联系人"+Environment.NewLine);
foreach (var contact in contacts)
Console.WriteLine("联系人: " + contact.Name.Trim()+" ID:"+contact.ContactID);
我们知道使用IEnumerable<T>迭代器可以产生延迟查询的行为，在上面代码中 contacts变量的类型不是IEnumerable<T>,而是IQueryable<Contact>．
处理IQueryable<Contact>数据与处理序列完全不同．IQueryable<Contact>的实例将要接受一棵表达式树，由些分析出下一步将要进行的操作．
在上面代码中，一旦我们开始遍历contacts变量，那么程序就会开始分析其中包含的表达式树，随后生成SQL语句并执行，最后该SQL语句的返回结果以Contact对象集合的形式给出．
与基于IEnumerable<T>的序列相比， IQueryable<Contact>更加强大，因为程序可以根据表达式树的分析结果进行智能地处理．通过查看某个查询的表达式树，编译器即可智能地进行推断并进行大量的优化．IQueryable<Contact>和表达式树的组合将给我们带来更强大的可定制能力．
原创文章,出自"博客园, 猪悟能'S博客" : http://www.cnblogs.com/hackpig/