很多朋友对LINQ子查询和延迟执行的用法还不是很明了，下面就通过一个实例来给大家展示LINQ子查询的相关用法。

LINQ子查询

LINQ子查询是一个包含了另外一个查询的Lambda表达式的查询. 以下的例子使用了一个LINQ子查询来针对篮球明星的last name排序:

string[] players = { "Tim Ducan", "Lebrom James", "Kobe Byrant" };   
IEnumerable<string> q = players.OrderBy (m => m.Split().Last()); 

在这其中, Last是一个LINQ子查询, q则代表了一个外部查询.

在LINQ子查询中, 你可以在Lambda表达式的右边使用任何可行的C#表达语法.LINQ 子查询只是一个简单的C#表达式, 这意味着所有适用于LINQ子查询的规则都可以推导到Lambda表达式上.

以下的查询取得一个字符数组中所有满足长度等于最小长度的字符序列:

string[] names = { "James","Jack","Landy","C.Y","Jay" };     
IEnumerable<string> q = names     
  .Where (n => n.Length ==     
     names.OrderBy (n2 => n2.Length)     
          .Select  (n2 => n2.Length).First( )     
  );     
foreach(var s in q)     
{     
    Console.WriteLine(s); //C.Y , Jay    
} 

对于LINQ子查询, 可以引用到外部的Lambda参数或者是迭代变量(在复合查询中). 例如上述的例子中, 如果OrderBy使用的表达式改为(n => n.Length)而不是用n2的话将会得到一个错误信息:

A local variable named ‘n’ cannot be declared in this scope because it would give a different meaning to ‘n’, which is already used in a ‘parent or current’ scope to denote something else.

针对这个例子, 我们可以看到对应的复合查询写法:

IEnumerable<string> q =     
  from n in names     
  where n.Length ==     
    (from n2 in names     
     orderby n2.Length     
     select n2.Length).First( )     
  select n; 

外部迭代变量n在LINQ子查询范围内是可见的, 因此我们不能将它重用为LINQ子查询内部的迭代变量.

LINQ子查询会在对应的Lambda表达式被执行的时候来执行, 其执行取决于外部查询, 也可以说是由外到里来处理的. 本地查询完全遵循这个模型, 但是解释型查询(例如LINQ to SQL)则仅仅是概念上遵循而已.

之前的查询我们还可以使用一种更加简洁的写法:

IEnumerable<string> q =     
  from n in names     
  where  n.Length ==     
         names.OrderBy (n2 => n2.Length).First().Length     
  select n; 

如果使用Min聚合函数, 还可以进一步简化:

IEnumerable<string> q =     
      from n in names     
      where n.Length == names.Min (n2 => n2.Length)     
      select n; 

实际上, 由于n2.Length在外部查询循环的时候每次都会重新计算, 这在某些情况下可能会引起效率问题, 避免这个问题, 我们可以将LINQ子查询分离出来:

int len = names.Min (n => n.Length);     
      
IEnumerable<string> query = from   n in names     
                            where  n.Length == len     
                            select n; 

子查询和延迟执行

在LINQ子查询中的返回单一元素或者聚合类操作符, 例如first或者Count, 并不会强制外部查询立即执行, 也就说外部查询依然拥有延迟执行的能力. 这是因为LINQ子查询是被间接调用的 – 如果是本地查询则是通过代理(delegate), 如果是解释性查询则是通过表达树(expression tree).

一个有趣的现象是当你的LINQ子查询中包含一个Select表达式的时候, 如果是本地查询, 你实际上是将其发散成一序列的查询 – 并且每一个都拥有延迟执行的能力. 这个影响是透明的, 因为它可以显著提高效率.

【编辑推荐】

1. LINQ——语言级集成查询入门指南
2. LINQ查询的目的与实现手段
3. 实例二：绑定到LINQ查询的结果
4. LINQ查询表达式深入剖析
5. LINQ的演变及其对C#设计的影响