C#基础：LINQ 查询函数整理

[TOC]

1、LINQ 函数

1.1、查询结果过滤 ：where()

---

 Enumerable.Where() 是LINQ 中使用最多的函数，大多数都要针对集合对象进行过滤，因此Where()在LINQ 的操作上处处可见，Where()的主要任务是负责过滤集合中的数据：其原型如下：

 public static IEnumerbale<TSouce> Where<TSource>(this IEnumerable<Tsource> source,Func<TSource,bool> predicate);
 public static IEnumerable<TSource>where<TSource> (this IEnumerable<TSource> source,Func<TSource,int,bool> predicate);

　　Where()的参数是用来过滤元素的条件，它要求条件必须传回bool，以确定此元素是否符合条件，或是由特定的元素开始算起（使用Func<TSource,int bool>,中间的传入参数代表该元素在集合中的索引值），例如要在一个数列集合中找出大于5的数字时：

 List<int> list1=new List<int>(){,,,,,};

 list1.Where(c=>c>);

或者

 list1.Where(c=>c>=).Where(c=>c<=);

 list1.Where(c=>c>=&&c<=); 

Where()的判断标准是，只要判断函数返回true 就成立，反之则取消。

1.2、选取数据： Select()、SelectMany()

---

通常在编写LINQ 函数调用时较少用到选取数据的函数（因为函数调用会直接返回IEnumerable<T> 集合对象 ），但在编写LINQ语句时十分常用，在语句中若编写了select new指令，它会被编译器转换成LINQ 的Select(),Select() 的原型如下：

 public static IEnumerable<TResult> Select<TSource,TResult>(this IEnumerable<TSource> source,Func<TSource,TResult> selector);
 public static IEnumerable<TResult> Select<TSource,TResult>(this IEnumerable<TSource> source,Func<TSource,int,TResult> selector);

      与Where()类似，Select() 也可以按照元素所在的位置判断处理，而Select()所指定的处理式selector 必须传回一个对象，这个对象可以是现有的类型，也可以是匿名的类型，既可以通过Select() 来重新组装所需数据。例：

 var query=db.OrderDetails.Where(o=>o.ID==).Select(o=>new{ ProductID=o.ProductID,Qty=o.Qty});

Select()的另一个相似函数SelectMay()则是处理有两个集合对象来源的数据选取，其原型如下：

     public static IEnumerable<TResult> SelectMany<TSource,TResult>(this IEnumerable<TSource> source,Func<TSource,IEnumberable<TResult>> selector);
     public static IEnumerable<TResult> SelectMany<TSource,TResult>(this IEnumerable<TSource> source,Func<TSource,int,IEnumberable<TResult>> selector);
     public static IEnumerable<TResult> SelectMany<TSource,TCollection,TResult>(this IEnumerable<TSource> source,Func<TSource,IEnumberable<TCollection>> collectionSelector,Func<TSource,TCollection,TResult> resultSelector);
     public static IEnumerable<TResult> SelectMany<TSource,TCollection,TResult>(this IEnumerable<TSource> source,Func<TSource,int,IEnumberable<TCollection>> collectionSelector,Func<TSource,TCollection,TResult> resultSelector);

      SelectMany() 在LINQ 函数调用上较难理解，但如果把它想象成数据库

CROSS JOIN ，相对来说就容易懂了，例：

 List<int> list1=new List<int>(){,,,,,};
 List<int> list2=new List<int>(){,,,,,};

 var query=list1.SelectMany(o=>list2);
 foreach(var q in query)
      Console.WriteLine("{0}",q);

输出结果：

因为“642790”输出了 6次，list1 内的元素是6个，所以可以知道SelectMany()会按照list1 内的元素个数调用它的selector，并组装集合输出。

1.3、群组数据：GroupBy()、ToLookup()

---

汇总数据是查询机制的基本功能，而在汇总之前，必须要先将数据做群组化，才能进行统计，LINQ 的群组数据功能由Enumerable.GroupBy()函数提供。

GroupBy() 会按照给定的key（keySelector）以及内容（elementSelector），产生群组后的结果（IGroup接口对象或是由resultSelector生成的结果对象），例：

  List<int> sequence =new List<int>(){,,,,,,,,,,};

  var group=sequence.GroupBy(o=>o);
  foreach(var g in group)
  {
       Console.WrilteLine("{0} count:{1}",g.Key,g.Count());
  /*计算每个数出现的次数。
 8      GroupBy 设置了使用数列本身值作为Key值，并且利用这个Key 分组产生分组的数据（IGrouping<TKey,TElement类型），再对分组的数据进行汇总。结果如下：
 9
10 1 count: 1
11 2 count: 3
12 3 count: 2
13 4 count: 4
14 6 count: 1
15
16 */

若是想要在返回之前对分组后的元素做处理，可以传入elementSelector 而若是要在元素处理后产生结果的话，则可以传入resultSelector，这样返回的集合会是以resultSelector 返回的类型为主，而不是默认的IGroup接口。

除了GroupBy（）能群组化数据外、另外一个具有群组化数据能力的是ToLookUp（），它可以生成具有群组化特性的集合对象，由ILookup<TKey,TElement>组成。

ToLookup（）看起来和GroupBy（）有些类似，但是它会另外生成一个新的集合对象，这个集合对象由ILookup<TKey,TElement>所组成，允许多个键值存在，且一个键值可包含许多关联的实值。例：

  var nameValuesGroup=new[]
  {
       new{name="Allen", value=,group="A"},
       new{name="Abbey",value=,group="B"},
       new{name="Sue",Value=,group="A"}
  };
  var lookupValues=namValuesGroup.ToLookup(c=>c.group);
  foreach(var g in lookupValues)
  {
      Console.WriteLine("===Group: {0}===",g.Key);
      foreach(var item in g)
      {
           Console.WriteLine("name:{0},value:{1}",item.name,item.value);
      }
 }

GroupBy（）本身具有延迟执行的特性，而ToLookup()没有。

1.4、联接数据： Join() 与GroupJoin()

---

身为一个查询机制，将两个集合进行联接（join）也是理所当然的，尤其是在进行数据的对比和汇总时，联接机制显得更重要。在LINQ 函数中，有 Enumerable.Join() 函数负责处理联接，其原型如下：

public static IEnumerable<TResult> Join<TOuter,TInner,TKey,TResult>(this IEnumerable<TOuter> outer,IEnumerable<TInner> inner,Func<TOutput,TKey> outerKeySelector,Func<TInner,TKey> innerKEySelector,Func<TOuter,TInner,TResult> resultSelector)
   

由原型可看到它将原本的集合视为TOuter，而将传入的集合视为TInner，儿还要决定由哪个属性或成员当Key，最后由resultSelector来输出联接的结果。例：

 var query=from item1 in list1
      join item2 in list2 on item1 equals item2
      select item2;
 var query3=list1.Join(
      list2,
      item1=>item1,
      item2=>item2,
      (item1,item2)=>item2
      );

Enumerable<T>.Join()使用的是INNER JOIN的概念，当TInner.Key 和TOuter.Key相同时，才会将元素输出到resultSelector 作为参数。

目前常用的联接模式，INNER JOIN由 Enumerable<T>.Join() 实现，CROSS JOIN 由Enumerable<T>.SelectMany() 实现，还有一种JOIN 模式没有考虑，LEFT OUTER JOIN模式，要实现这个模式，必须要借助GroupJoin()方法来实现。

GroupJoin 和 Join() 十分相似，不过它却又Join() 和GroupBy()两者的功能，在Join() 的情况下，它会留下TInner 和TOuter两边都有的值，但在GroupJoin(),它会将TOuter 的值作为Key，并依此来对TInner 做群组化后输出，例：

 var query4=from item1 in list1
           join item2 in list2 on item1 equals item2 into g
           from item in g.DefaultIfEmpty()
           select new{ v=item1,c=item};
 var query5=list1.GroupJoin(
           list2,
           item1=>item1,
           item2=>item2,
           (item1,item2)=>new {v=item1,c=item2.Count()});

1.5、数据排序：OrderBy() 与ThenBy()

---

数据排序是在数据处理中常见的功能，在LINQ 内的排序主要是以OrderBy函数为主，而为了支持连续条件的排序，可加上ThenBy 函数，以便处理多重条件排序的需求。基于LINQ的延迟查询机制，排序也不是在一开始就进行的，而是在数据真的被访问时才会进行排序。因此OrderBy()在处理集合时，传递回来的是称为IOrderedEnumerable<T> 接口的对象。

OrderBy和ThenBy还有一个相似的方法，差别只在于做反向排序。OrderByDescending 和ThenByDescending。

观察函数的原型，会发现OrderBy传入的是IEnumerable<T> ,但ThenBy传入的是IOrderedEnumerable，所以一般在排序时先调用OrderBy，再使用ThenBy进行多重排序。假设一个集合有A和B两个属性，如果想要先为A排序再为B排序，则要使用OrderBy(A).ThenBy(B)的方式来进行排序，OrderBy和ThenBy一次调用只能设置一个字段，在进行多重条件时，必须先调用OrderBy，再按需求调用ThenBy一次或多次。例：

   var nameValues=new[]
  {
       new {name="Allen",value=},
       new {name="abbey",value=},
       new {name="slomng",value=},
       new {name="george",value=}
  };
  //single sort
  var sortedNames=nameValues.OrderBy(c=>c.name);
 var sortedValues=nameValues.OrderBy(c=>c.value);

 //multiply sort conditions
 var sortedByNameValues=nameValues.OrderBy(c=>c.name).ThenBy(c=>c.value);
 var sortedByValueNames=nameValues.OrderBy(c=>c.value).ThenBy(c=>c.name);

如果要设置多重排序条件，请务必使用OrderBy()加上ThenBy()的组合，若使用OrderBy +OrderBy 组合，会使得排序被执行两次，最终的结果会是最后一个OrderBy 所产生的的结果。

1.6、获取集合

---

LINQ 所处理的数据都由集合而来，因此将LINQ 执行的结果转换成集合也很容易。LINQ本身支持四种不同的集合生成方式，包含生成数组的ToArray()、生成列表的ToList、生成字典集合的ToDictionary 以及生成Lookup<TKey,TElement>类的ToLookup。例：

 var arrayOutput=nameValues.ToArray();
 var listOutput=nameValues.ToList();

 var dictOutput1=nameValues.ToDictionary(c=>c.name);
 var dictOutput2=nameValues.ToDictionary(c=>c.name,c=>value);
 

1.7、划分并获取集合

---

Skip()、 SkipWhile()、 Take()、 TakeWhile()。在数据库查询时，为了达到最佳的性能，在数据量大时要进行分页处理（paging）。上面四个函数的功能就是在大集合内切出少量数据。

  public static IEnumberable<TSource> Skip<TSource>(
       this IEnumerable<TSource> source,
       int count
  )
  public static IEnumberable<TSource> SkipWhile<TSource>(
       this IEnumerable<TSource> source,
       Func<TSource,bool> predicate
  )
  public static IEnumberable<TSource> SkipWhile<TSource>(
      this IEnumerable<TSource> source,
      Func<TSource,int ,bool> predicate
 )
 public static IEnumberable<TSource> Take<TSource>(
      this IEnumerable<TSource> source,
      int count
 )
 public static IEnumberable<TSource> TakeWhile<TSource>(
      this IEnumerable<TSource> source,
      Func<TSource,bool> predicate
 )
 public static IEnumberable<TSource> TakeWhile<TSource>(
      this IEnumerable<TSource> source,
      Func<TSource,int ,bool> predicate
 )

Skip()用来在集合中跳跃，让LINQ 核心直接将游标跳到指定的位置，而不用通过“巡航”来移动，在大型集合中可节省不少时间，而SkipWhile 也有相同作用，但多了判断式，也就是跳过符合条件的元素，而不同的SkipWhile()可用来决定要跳过符合条件的或是判断跳过特定的索引值。

Take()用来传回集合中特定数量的元素，它会告知LINQ 核心直接返回它所指定的元素数量，很适合使用与分页的功能。TakeWhile 则是和SkipWhile 类似都是多了条件判断式，不过TakeWhile 在元素满足条件时，就返回该元素或是符合特定的索引值条件时返回该元素。

1.8、访问元素

---

IEnumerable<T>本身就是集合对象，所以针对集合对象所需要的元素访问也是必要的功能，LINQ里的元素访问功能是判断容器内是否含有元素等。

首先是获取首尾的元素，分别由First() 以及Last()两个方法负责，它们还各有一个姐妹方法FirstOrDefault()以及LastOrDefault()前者若没有第一个或最后一个元素时，会传回null，而后者会传回其类型的默认值（基本上就是default(T)的结果）。

FirstOrDefault() 以及 LastOrDefault()都没有提供默认的设置方式，因此若想要使用非default(T)的默认值，要使用DefaultEmpty()来设置。First() 和Last() 都能传入判断元素是否符合条件的参数，当条件判断存在时，First 会从集合的前面开始扫描，并返回扫描到符合条件的第一个元素，Last 则是反过来从集合的尾端开始扫描，并返回扫描到符合条件的第一个元素。例：

 var firstLastItems=new []{"zero","two","three","four","five"};
 string firstContainsO=firstLastItems.First(s=>s.Contains('o'));
 string lastContainsO=firstLastItems.Last(s=>s.Contains(''));

　　LINQ 内还有一个Single，他会在集合中只有一个元素时传回该元素，但若集合是空的或是有两个以上的元素时会调用例外处理，或是使用它的姐妹方法SingleOrDefault 传回null值，实用性比fisrt和last 低。

LINQ 提供了ElementAt()这个方法，可按照索引值访问元素，他有个相似方法ElementAtOrDefault作用和firstordefault/lastordefault 是相同的。当找不到元素时就返回默认值。例：

 var firstLastItems=new []{"zero","two","three","four","five"};
 string itematThree=firstLastITems.ElementAt();

若要判断集合内有没有特定值，LINQ 提供了Contains, 可以判断集合捏有没有传入的元素，但因为Contain 会判断对象是否相等，所以它另外提供了一个可传入IEqualityComparer<T> 的作为比较依据的重载（overload）方法，可用于自定义类对象的相等比较操作。

若要判断集合内有没有值，LINQ 提供了两个方法，一个是Count（）, 另一个是Any（），除了可以简单判断集合内有没有值外，也可以传入判断条件来决定是否要列入计算。通常会习惯使用Count 来判断集合内是否存在任何元素，为什么要多做一个Any呢。其实是考虑到LINQ 可能的查询对象会包含远程数据库，不一定只有本地的数据源。对于远程的数据源，如果使用Count ，要花费较高的成本来读取数据后进行计数在传回，但若是使用Any(),则远程只要判断符合条件的数据是否存在一笔即可，不需要完整计数，所以针对远程数据源，使用Any 来判断有无数据是较好的选择。针对本地的集合 any 和count 几乎没有差异。

若要判断集合内的元素是否全部符合特定条件时， 可以利用LINQ 的All(), 它可以按照传入的条件来扫描所有元素，只有在所有元素都符合条件时，或是集合时空时才会返回true ，否则会返回false。

若要按照元素的类型进行筛选的话，除了使用Where 对每个元素做类型信息判断外，LINQ 也提供了一个更简便的方法 OfType<T>()，它可以传回集合内符合T所指定类型的信息，这个方法很适合用在集合内包含了已实现了许多接口的类对象。然后使用OfType<T>按照接口类型进行筛选。

OfType<T>还有一个类似方法Cast<T> ，功能与OfType <T>相同，但Cast<T>会试图把集合内的元素类型转换成T类型，若无法进行类型转换时会调用InvalidCastException 例外处理。若使用OfType<T>则不会引发例外处理。

1.9、聚合与汇总

---

聚合运算（aggregation）是集合数据处理的重要功能之一，基本的Max ,Min ,Sum ,Average 以及可自己制定聚合规则的Aggregate()。

Aggregate 是可暂存每一步计算结果的方法，它允许程序员按照传入的条件对每个集合内的元素进行计算，而在每次调用时，他都会将前一次的结果暂存起来，并作为下次计算的传入参数。Aggregate 基本上做到三种工作，第一种是直接按照传入的条件来处理累计运算；第二种是可在调用时传入一个种子值（seed），这个种子值会在开始进行运算时作为基准使用，之后可按照第一次对种子值的运算方式开始做累计运算；第三种则是在传回之前做最后的处理，例：

  double myBalance=100.0;

  int[] withdrawItems={,,,,,,};

  double balance=withdrawItems.Aggregate(myBalance,(originbalance,nextWithdrawal)=>{
       Console.WriteLine("originbalance:{0},nextWithdrawak:{1}",originbalance,nextdrawal);
       Console.WriteLine("Withdrawal status:{0}",(nextWithdrawal<=originbalance)?"OK":"FAILED");

       return ((nextWithdrawal<=originbalance)?(originbalance-nextWithdrawal):originbalance);
 });
 Console.WriteLine("Ending balance:{0}:",balance);

若要对最终的存款值进行处理，即可使用第三个参数resultSelector，例：

 var balanceStatus=
 withdrawItems.Aggregate(myBalance,(originbalance,nextWithdrawal)=>{
      return((nextWithdrawal<=originbalance)?(originbalance-nextWithdrawal):originbalance);

 },
 (finalbalance)=>
 {
      return (finalbalance>=)?"Normal":"Lower";
 });

2、标准的查询操作符

2.1 筛选

---

例：找出赢得至少15场比赛的碧玺和奥地利赛车手。代码如下：

 var racers=from r in Formula1.GetChampions()
           where r.Wins >  && (r.Country=="Brazil"||r.Country=="Austria")
           select r;

 foreach(var r in racers)
 {
      Console.WriteLine("{0:A}",r);
 }

下面使用Where()  和 Select() 的代码：

 var racers=Formula1.GetChampions().
           Where(r=>r.Wins> && (r.Country=="Brazil" || r.Country=="Austria")).
           Select(r=>r);

2.2 用索引筛选

---

不能使用LINQ 查询的一个例子是Where 方法的重载。在Where 方法的重载中，可以传递第二个参数——索引。索引是筛选器返回每个结果的计数器。可以在表达式中使用这个索引， 执行基于索引的计算。下面的代码由Where 扩展方法调用，它使用索引返回姓氏以“A” 开头，索引为偶数的赛车手。

 var racers=Formula1.GetChamptions().
           Where((r,index)=>r.LastName.StartsWith("A") && index %  !=);

 foreach(var r in racers)
 {
      Console.WriteLine("{0,A}",r);
 }
  

2.3 类型筛选

---

为了进行基于类型的筛选，可以使用OfType扩展方法。这里数组数据包含string 和 int 对象。 使用OfType扩展方法，把string类传递给泛型参数，就从集合中返回字符串。

 object[] data={"ones",,,"fre","fdfs",};
  var query=data.OfType<string>();
  foreach(var s in query)
  {
       Console.WriteLine(s);
  }
   /*
 8      运行结果为：
 9
10 ones
11 fre
12 fdfs
13 */

2.4 复合的from 子句

---

如果需要根据对象的一个成员进行筛选，而该成员本身是一个系列，就可以使用复合的from 子句。Racer 类定义了一个属性Cars，其中Cars 是一个字符串数组。要筛选驾驶法拉利的所有冠军，可以使用如下所示的LINQ 查询。第一个from子句访问从Formula1.GetChampion()方法返回的Race 对象，第二个from 子句访问Racer的 Cars 属性。以返回所有string 类型的赛车。接着在where 子句中使用这些赛车筛选驾驶法拉利的所有冠军。

 var ferrariDrivers=from r in Formula.GetChampions()
                     from c in r.Cars
                     where c=="Ferrari"
                     orderby r.LastName
                     select r.FirstName +" "+ r.LastName;

C# 编译器把符合的from 子句和LINQ 查询转换为SelectMany 扩展方法。其中实例所用的重载版本如下

 public static IEnumerable<TResult> SelectMany<TSource,TCollection,TResult>(this IEnumerable<TSource> source,Func<TSource,IEnumberable<TCollection>> collectionSelector,Func<TSource,TCollection,TResult> resultSelector);

     第一个参数是隐式参数，它从 Get.Champions()方法中接收Racer 对象序列。第二个参数是collectionSelector委托，其中定义了内部序列。在Lambda 表达式 r=>r.Cars 中，应返回赛车集合。第三个委托参数是一个委托，现在为每个赛车调用给委托，接收Racer 和Car 对象。Lambda 表达式创建了以匿名类型，他有Racer 和 Car 类型。 这个SelectMany方法的结果是摊平了赛车手和赛车的层次结构，为每辆赛车返回匿名类型的一个新对象集合。

 var ferrariDrivers= Formula1.GetChampion().
                     SelectMany(r=>r.Cars,
                          (r,c)=>new{Racer=r,Car=c}.
                          where(r=>r.Car=="Ferrari").
                          OrderBy(r=>r.Racer.LastName).
                          Select(r=>r.Racer.FirstName+" "+r.Racer.LastName));

2.5 排序

---

　　要对序列排序，前面使用了 orderby 子句。下面复习一下前面使用的orderby descending 子句的例子。其中赛车手按照赢得比赛的次数进行降序排序，赢得比赛的次数用关键字选择器指定。

 var racers=from r in Formula1.GetChampions()
            where r.Country=="Brazil"
            orderby r.Wins descending
            select r;

orderby 子句解析为OrderBy( ) 方法，orderby descending子句解析为OrderByDescending方法

 var racers= Formula1.GetChampions().
           Where(r=>r.Country=="Brazil").
           OrderByDescending(r=>r.Wins).
           Select(r=>r);

使用LINQ 查询时，只需把所有用于排序的不同关键字（用逗号隔开）添加到orderby子句中。在下例中，所有的赛车手先按照国家排序，再按照姓氏排序，最后按照名字排序。添加到LINQ 查询结果中的Take()扩展方法用于提取前十个结果：

 var racers=(from r in Formula1.GetChampions()
                orderby r.Country,r.LastName,r.FirstName
                select r).Take();

使用OrderBy和ThenBy扩展方法可以执行相同的操作

 var racers=Formula1.GetChamptions().
      OrderBy(r=>r.Country).
      ThenBy(r=>r.LastName).
      ThenBy(r=>r.FirstName).
      Take();

2.6 分组

---

要根据一个关键字值对查询结果分组，可以使用group子句。 现在一级方程式冠军应该按照国家分组，并列出一个国家的冠军数。子句group r by r.County into g根据 Country 属性组合所有的赛车手，并定义一个新的标识符g， 它以后用于访问分组的结果信息。group子句的结果应该根据应用到分组结果上的扩展方法Count来排序，如果冠军数相同，就根据关键字排序，该关键字是国家，因为这是分组使用的关键字。where 子句根据至少有两项的分组来筛选结果。select 子句创建一个带Country和Count属性的匿名类型。

  var countries= from r in Formula1.GetChampions()
                 group r by r.Country into g
                 orderby g.Count() descending, g.Key
                 where g.Count() >=
                 select new {
                                Country=g.Key,
                                Count=g.Count()
                           };
  foreach(var item in countries)
 {
      Console.WriteLine("{1,-10} {1}",item.Country,item.Count);
 }

接下来把子句 group r by r.Country into g解析为GroupBy(r=>r.Country),返回分组序列。分组序列首先用OrderByDescending方法排序，再用ThneBy 方法排序。接着调用Where 和Select 方法

 var countries= Formula1.GetChampions().
                GroupBy(r=>r.Country).
                OrderByDescending(g=>g.Count()).
                ThenBy(g=>g.Key).
                Where(g=>g.Count()>=).
                Select(g=>new {Country=g.Key,Count=g.Count()});

2.7 对嵌套的对象分组

---

如果分组的对象应包含嵌套的序列，就可以改变select子句创建的匿名类型。在下面的例子中，所返回的国家不仅应包含国家名和赛车手数量这两个属性，还应包含赛车手名序列。这个序列用一个赋予Racers属性的from/ in 内部子句指定，内部的from 子句使用分组标识符g获得该分组中的所有赛车手，用姓氏对它们排序，再根据姓名创建一个新字符串。

  var countries=from r in Formula1.GetChampions()
                 group r by r.Country into g
                 orderby g.Count() descending, g.Key
                 where g.Count()>=
                 select new
                 {
                      Country=g.Key,
                      Count=g.Count(),
                      Racers=from r1 in g
                            orderby r1.LastName
                            select r1.FirstName +" "+ r1.LastName
                };
 foreach(var item in countries)
 {
      Console.WriteLine("{0,-10} {1}",item.Country,item.Count);
      foreach(var name in item.Racers)
      {
           Console.WriteLine("{0};",name);
      }
      Console.WirteLine();
 }

2.8 内连接

---

使用join 子句可以根据特定的条件合并两个数据源，但之前要获得两个要连接的列表。在一级方程式比赛中，有赛车手冠军和车队冠军。赛车手从GetChampions 方法中返回，车队从GetConstructionChampions方法中返回。现在要获得一个年份列表，列出每年的赛车手冠军和车队冠军。

  var racers= from r in Formula1.GetChampions()
              from y in r.Years
              select new
              {
                 Year=y,
                 Name=r.FirstName+" "+r.LastName
               };

  vat teams=from t in Formula1.GetConstructorChampions()
           from y in t.Years
           select new
           {
                Year=y,
                Name=t.Name
           };
 var racersAndTeams=(from r in racers
                     join t in teams on r.Year equals t.Year
                     select new
                     {
                          r.Year,
                          Champion=r.Name,
                          Constructor=t.Name
                     }).Take();
 Console.WriteLine("Year World Champion\t Constructor Title");
 foreach(var item in racersAndTeams)
 {
      Console.WriteLine("{0}:{1,-20} {2}",item.Year,item.Champion,item.Constructor);
 }

或者合并成一个LINQ 查询

  var racersAndTeams=(from r in
                      from r1 in Formula1.GetChampions()
                      from yr in r1.Years
                      select new
                      {
                           Year=yr,
                           Name=r1.FirstName+" "+r1.LastName
                      }
                      join t in
                          from t1 in Formula1.GetConstructorChampions()
                          from yt in t1.Years
                          select new
                          {
                               Year=yt,
                               Name=t1.Name
                          }
                     on r.Year equals t.Year
                     orderby t.Year
                     select new
                     {
                          Year=r.Year,
                          Racer=r.Name,
                          Team=t.Name
                     }).Take();

2.9 左外连接

---

上一个连接示例的输出从1958 年开始，因为从这一年开始，才同时有了赛车手冠军和车队冠军。赛车手冠军出现的更早一些，是在1950年。使用内连接时，只有找到了匹配的记录才返回结果。为了在结果中包含所有的年份，可以使用左外联接。左外连接返回左边序列中的全部元素，即使它们在右边的序列中并没有匹配的元素。

下面修改前面的LINQ 查询，使用左外连接。左外连接使用 join 子句和DefaultIfEmpty 方法定义。如果查询的左侧（赛车手）没有匹配的车队冠军，那么就使用DefaultIfEmpty方法定义其右侧的默认值。

  var racersAndTeams=
       (from r in racers
       join t in teams on r.Year equals t.Year into rt
       from t in rt.DefaultIfEmpty()
       orderby r.Year
       select new
       {
            Year=r.Year,
            Champion=r.Name,
           Constructor=t==null?"no constructor championship":t.Name
      }).Take();

2.10 组连接

---

左外连接使用了组连接和into 子句。它有一部分语法与组连接相同，只不过组连接不使用DefaultIfEmpty方法。

使用组连接时，可以连接两个独立的序列，对于其中一个序列中的某个元素，另一个序列中存在对应的一个项列表。

下面的示例使用了两个独立的序列。一个是前面例子中已经看过的冠军列表，另一个是一个ChampionShip类型的集合。下面的代码段显示了Championship类。

 public class Championship
 {
      public int Year{get;set;}
      public string First{get;set;}
      public string Second{get;set;}
      public string Third{get;set;}
 }

GetChampionships 返回了冠军集合

  private static List<Championship> championships;
  public static IEnumerable<Championship> GetChampionships()
  {
       if(championships == null)
       {
            championships=new List<Championship>();
            championships.Add(new Championship
            {
                 Year=,
                First="Nino Farina",
                Second="Juan Manuel Fangio",
                Third="Luigi Fagioli"
           });
           championships.Add(new Championship
           {
                Year=,
                First="Juan Manuel Fangio",
                Second="Alberto Ascari",
                Third="Froliab Gonzalez"
           });
      }

冠军列表应与每个冠军年份中获得前三名的赛车手构成的列表组合起来，然后显示每一年的结果。

RacerInfo类定义了要显示的信息，如下所示：

 public class RacerInfo
 {
      public int Year{get;set;}
      public int Position {get;set;}
      public string FirstName{get;set;}
      public string LastName{get;set;}
 }

使用连接语句可以把两个列表中的赛车手组合起来。

因为冠军列表中的每一项都包含三个赛车手，所以首先需要把这个这个列表摊平。一种方法是使用SelectMany 方法，该方法使用的Lambda 表达式为冠军列表中的每一项返回包含三项的一个列表。在这个Lambda 表达式的实现中，因为RacerInfo 包含FirstName和LastName 属性，而收到的集合只包含带有First 、Second、Third 属性的一个名称，所以必须拆分字符串，这可以通过扩展方法 FirstName 和SecondName 完成。

  var racers=Formula1.GetChampionships()
            .SelectMany(cs=>new List<RacerInfo>()
            {
                 new RacerInfo{
                      Year=cs.Year,
                      Position=,
                      FirstName=cs.First.FirstName(),
                      LastName=cs.Last.LastName()
                 },
                new RacerInfo{
                     Year=cs.Year,
                     Position=,
                     FirstName=cs.Fisrt.FirstName(),
                     LastName=cs.Last.LastName()
                },
                new RacerInfo{
                     Year=cs.Year,
                     Position=,
                     FirstName=cs.First.FirstName(),
                     LastName=cs.Last.LastName()
                }
           });

扩展方法FirstName 和SecondName 使用空格字符拆分字符串：

  public static class StringExtension
  {
       public static string FirstName(this string name)
       {
            int ix=name.LastIndexOf(' ');
            return name.Substring(,ix);
       }
       public static string LastName(this string name)
       {
           int ix=name.LastIndexOf(' ');
           return name.Substring(ix+);
      }
 }

现在就可以连接两个序列。Formula1.GetChampions 返回一个Racers 列表，racers 变量返回包含年份、比赛结果和赛车手名字的一个RacerInfo 列表。仅使用姓氏比较两个集合中的项是不够的。有时候列表中可能同时包含了一个赛车手和他的父亲，所以必须同时使用FirstName 和LastName 进行比较。这是通过为两个列表创建一个新的匿名类型实现的。通过使用into 子句，第二个集合中的结果被添加到了变量yearResults中。对于第一个集合中的每一个赛车手，都创建了一个yearResults. 它包含了在第二个集合中匹配名和姓的结果。最后，用LINQ 查询创建了一个包含所需信息的新匿名类型。

  var q=(from r in Formula1.GetChampions()
            join r2 in racers on
            new
            {
                 FirstName=r.FirstName,
                 LastName=r.LastName
            }
            equals
            new
           {
                FisrtName=r2.FirstName,
                LastName=r2.LastName
           }
           into yearResults
           select new
           {
                FirstName=r.FirstName,
                LastName=r.LastName,
                Wins=r.Wins,
                Stars=r.Stars,
                Results=yearResults
           });
 foreach(var r in q)
 {
      Console.WriteLine("{0} {1}",r.FirstName,r.LastName);
      foreach(var results in r.Results)
      {
           Console.WriteLine("{0} {1}.",results.Year,results.Position);
      }
 }

2.11 集合操作

---

扩展方法 Distinct、Union、Intersect、Except都是集合操作。下面创建一个驾驶法拉利的一级方程式冠军序列和驾驶迈凯伦的一级方程式冠军序列，然后确定是否有驾驶法拉利和迈凯伦的冠军。

 var ferrariDrivers=from r in
                     Formula1.GetChampions()
                     from c in r.Cars
                     where c =="Ferrari"
                     orderby r.LastName
                     select r;

现在建立另一个基本相同的查询，但where 子句的参数不同，以获得所有驾驶迈凯伦的冠军。最好不要再次编写相同的查询，而可以创建一个方法，其中给它传递参数 car

 private static IEnumerable<Racer> GetRacersByCar(string car)
 {
      return from r in Formula1.GetChampions()
                from c in r.Cars
                where c==car
                orderby r.LastName
                select r;
 }

但是，因为该方法不需要再其他地方使用，所以*应定义一个委托类型的变量来保存LINQ 查询，racerByCar变量必须是一个委托类型，该委托类型需要一个字符串参数，并返回IEnumerable<Racer>,类似于前面实现的方法。为此，定义了几个泛型委托Func<>, 所以不需要声明自己的委托。把一个Lambda 表达式赋予racerByCar变量。Lambda 表达式的左边定义了一个car 变量。其类型时Func 委托的第一个泛型参数（字符串）。右边定义了LINQ 查询，它使用该参数和where 子句：

 Func<string , IEnumerable<Racer>> racersByCar=
                car=>from r in Formula1.GetChampions()
                     from c in r.Cars
                     where c==car
                     orderby r.LastName
                     select r;

现在可以使用Intersect 扩展方法 ，获得驾驶法拉利和迈凯伦的所有冠军：

 Console.WriteLine("World champion with Ferrari and McLaren");
 foreach(var racer in racersByCar("Ferraris").Interesect(racersByCar("McLaren")))
 {
      Console.WirteLine(racer);
 }

　　集合操作通过调用实体类的GetHashCode 和Equals 方法来比较对象。对于自定义比较，还可以传递一个实现了IEqualityComparer<T>接口的对象。在这个示例中，GetChampions方法总是返回相同的对象，因此默认的比较操作时有效的，如果不是这种情况，就可以重载集合方法来自定义比较操作。

2.12 合并

---

Zip() 方法，允许用一个谓词函数把两个相关的序列合并为一个。

首先，创建两个相关的序列，它们使用相同的筛选和排序方法。对于合并，这很重要，因为第一个集合中的第一项会与第二个集合中的第一项合并，第一个集合中的第二项会与第二个集合中的第二项合并，以此类推。如果两个序列的项数不同，Zip 方法就在到达较小集合的末尾时停止。

第一个集合中的元素有一个Name属性，第二个集合中的元素有LastName 和Starts 两个属性

在racerNames集合上使用Zip 方法，需要把第二个集合（racerNamesAndStarts）作为第一个参数。第二个参数的类型时Func<TFirst, TSecond, TResult> 这个参数实现为一个Lambda 表达式，它通过参数first 接收第一个集合的元素，通过参数second 接收第二个集合的元素。其实现代码创建并返回一个字符串，该字符串包含第一个集合中元素的Name属性和第二个集合中元素的Starts 属性。

  var racerNames=from r in Formula1.GetChampions()
                 where r.Country =="Italy"
                 orderby r.Wins descending
                 select new
                 {
                      Name=r.FirstName +" "+ r.LastName
                 };
  var racerNamesAndStarts=from r in Formula1.GetChampions()
                           where r.Country="Italy"
                          orderby r.Wins descending
                          select new
                          {
                               LastName=r.LastName,
                               Starts=r.Starts
                          };
 var racers=racerNames.Zip(racerNamesAndStarts,(first,second)=>first.Name+", starts: "+second.Starts);
 foreach(var r in racers)
 {
      Console.WriteLine(r);
 }

2.13 分区

---

扩展方法Take 和Skip 等的分区操作可用于分页，例如在第一个页面上只显示5个赛车手，在下一个页面上显示接下来的5个赛车手。

在下面的LINQ 查询中，把扩展方法Skip 和Take 添加到查询的最后。Skip 方法先忽略根据页面大小和实际页数计算出的项数，再使用Take() 方法根据页面大小提取一定数量的项。

 int pageSize=;

  int numberPages=(int)Math.Ceiling(Formula1.GetChampions().Count()/(double)pageSize);
  for(int page=;page<numberPages;page++)
  {
       Console.WriteLine("Page {0}",page);
       var racers=(from r in Formula1.GetChampions()
                      orderby r.LastName,r.FirstName
                      select r.FirstName+" "+r.LastName).
                     Skip(page*pageSize).Take(pageSize);
      foreach(var name in racers)
      {
           Console.WriteLine(name);
       }
      Console.WriteLine();
 }
  

这个分页机制的一个要点是，因为查询会在每个页面上执行，所以改变底层的数据会影响结果。在继续执行分页操作时，会显示新对象。根据不同的情况，这对于应用程序可能有利。如果这个操作时不需要的，就可以只对原来的数据源分页，然后使用映射导到原始数据上的缓存。

使用TakeWhile和 SkipWhile 扩展方法，还可以传递一个谓词，根据谓词的结果提取或跳过某些项。

2.14 聚合操作符

---

聚合操作符（如 Count、Sum、 Min、Max、Average、Aggregate） 不返回一个序列，而返回一个值。

Count扩展方法返回集合中的项数。下面的Count 方法应用于Racer 的Year 属性，来筛选赛车手，只返回获得冠军次数超过三次的赛车手，因为同一个查询中需要使用同一个计数超过一次，所以使用let 子句定义了一个变量 numberYear

  var query=from r in Formula1.GetChampions()
            let numberYears=r.Years.Count()
            where numberYear>=
            orderby numberYears descending, r.LastName
            select new
            {
                 Name=r.FirstName+" "+r.LastName,
                 TimesChampion=numberYears
            };
 foreach(var r in query)
 {
      Console.WriteLine("{0} {1}",r.Name,r.TimesChampion);
 }
  

Sum 方法汇总序列中的所有数字，返回这些数字的和。下面的Sum 方法用于计算一个国家赢得比赛的总次数。首先根据国家对赛车手分组，再在新创建的匿名类型中，把Wins 属性赋予某个国家赢得比赛的总次数。

  var countries=(from c in from r in Formula1.GetChampions()
                 group r by r.Country into c
                 select new
                 {
                      Country=c.Key,
                      Wins=(from r1 in c select r1.Wins).Sum()
                 }
                 orderby c.Wins descending, c.Country
                 select c).Take();
 foreach(var country in countries)
 {
      Console.WriteLine("{0} {1}",country.Country,country.Wins);
 }

对于Aggergate方法， 可以传递一个Lambda表达式，该表达式对所有的值进行聚合。

2.15 转换操作符

---

前面提到，查询可以推迟到访问数据项时在执行。在迭代中使用查询时，查询会执行。而使用转换操作符会立即执行查询，把查询结果放在数组、列表或字典中。

在下面的例子中，调用ToList 扩展方法，立即执行查询，得到的结果放在List<T> 类中。

 List<Racer> racers=(from r in Formula1.GetChampions()
                     where r.Starts>
                     orderby r.Starts descending
                     select r).ToList();
 foreach(var racer in racers)
 {
      Console.WriteLine("{0} {0:S}",racer);
 }

把返回的对象放在列表中并没有那么简单。例如，对于集合类中从赛车到赛车手的快速访问。可以使用新类Lookup<TKey,TElement>

　　Dictionary<TKey,TValue> 类只支持一个键对应一个值。在System.Linq名称空间的类Lookup<TKey,TElement>类中，一个键可以对应多个值。

使用复合的from 查询，可以摊平赛车手和赛车序列，创建带有Car 和Racer 属性的匿名类型。在返回的Lookup 对象中，键的类型应是表示汽车的string，值的类型应是Racer。 为了进行这个选择，可以给ToLookUp 方法的一个重载版本传递一个键和一个元素选择器。键选择器引用Car 属性镁元素选择器引用Racer 属性。

  var racers=(from r in Formula1.GetChampions()
                 from c in r.Cars
                 select new
                 {
                      Car=c,
                      Racer=r
                 }).ToLookup(cr=>cr.Car,cr=>cr.Racer);
  if(racers.Contains("Williams"))
  {
      foreach(var williamsRacer in Racers["Williams"])
      {
           Console.WriteLine(williamsRacer);
      }
 }

如果需要在非类型化的集合上（如ArrayList）使用LINQ 查询，就可以使用Cast 方法。在下面的例子中，基于Object类型的ArrayList集合用Racer 对象填充。为了定义强类型化的查询，可以使用Cast 方法

  var list=new System.Collections.ArrayList(Formula1.GetChampions() as System.Collections.ICollection);

  var query= from r in list.Cast<Racer>()
            where r.Country=="USA"
            orderby r.Wins descending
            select r;
  foreach(var racer in query)
  {
       Console.WriteLine("{0:A}",racer);
 }

2.16 生成操作符

生成操作符Range、 Empty、Repear不是扩展方法，而是返回序列的正常静态方法。在LINQ to Objects 中，这些方法可用于Enumerable 类。

      有时需要填充一个范围的数字，此时就应使用Range 方法，这个方法把第一个参数作为起始值，把第二个参数作为要填充的项数。

 var values =Enumerable.Range(,);
 foreach(var item in values)
 {
      Console.WriteLine("{0}",item);
 }
 Console.WriteLine();

 //结果 1 2 3 4 5 6 ......  19 20

 

Range 方法 不返回填充了所定义值的集合，这个方法与其他方法一样，也推迟执行查询，并返回一个RangeEnumerator ，其中只有一条yield return 语句，来递增值。

 

     可以把该结果与其他扩展方法合并起来，获得另一个结果。例如，使用Select 扩展方法

 

 var values =Enumerable.Range(,).Select(n=>n*);

 

     Empty 方法返回一个不返回值的迭代器，他可以用于需要一个集合的参数，其中可以给参数传递空集合。

     Repeat 方法返回一个迭代器，该迭代器把同一个值重复特定的次数。 

---