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

[TOC]

 

1、LINQ 函数

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


Enumerable.Where() 是LINQ
中应用最多之函数,大多数都如针对性集合对象开展过滤,因此Where()每当LINQ
的操作及各方可见,Where()的首要任务是背过滤集合中之数:其原型如下:

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

 

   Where()的参数是因此来过滤元素的规范,它要求标准必须传回bool,以确定这因素是否符合条件,或是由特定的素开始算从(使用Func<TSource,int bool>,中间的传遍参数代表该因素以集聚中之索引值),例如要当一个数列集合中觅有超过5底数字时:

1 List<int> list1=new List<int>(){6,4,2,7,9,0};
2  
3 list1.Where(c=>c>5);

 

或者

1 list1.Where(c=>c>=1).Where(c=>c<=5);
2  
3 list1.Where(c=>c>=1&&c<=5); 

 

 Where()的判定标准是,只要判断函数返回true 就确立,反的则取消。

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


     通常在编写LINQ
函数调用时比较少用到选择数据的函数(因为函数调用会直接返回IEnumerable<T>
集合对象 ),但每当编写LINQ语句时生常用,在言语中若编写了select new命,它见面让编译器转换成LINQ
Select(),Select() 的原型如下:

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

 

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

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

 

     
Select()的别样一个般函数SelectMay()尽管是拍卖发生一定量独聚众对象来之数据选取,其原型如下:

1     public static IEnumerable<TResult> SelectMany<TSource,TResult>(this IEnumerable<TSource> source,Func<TSource,IEnumberable<TResult>> selector);
2     public static IEnumerable<TResult> SelectMany<TSource,TResult>(this IEnumerable<TSource> source,Func<TSource,int,IEnumberable<TResult>> selector);
3     public static IEnumerable<TResult> SelectMany<TSource,TCollection,TResult>(this IEnumerable<TSource> source,Func<TSource,IEnumberable<TCollection>> collectionSelector,Func<TSource,TCollection,TResult> resultSelector);
4     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 ,相对来说就便于理解了,例: 

1 List<int> list1=new List<int>(){1,2,3,4,5,6};
2 List<int> list2=new List<int>(){6,4,2,7,9,0};
3  
4 var query=list1.SelectMany(o=>list2);
5 foreach(var q in query)
6      Console.WriteLine("{0}",q);

 

      输出结果:

1 6424790642790642790642790642790642790

 

      因为“642790”输出了 6次,list1
内之要素是6只,所以可以掌握SelectMany()会面随list1
内之因素个数调用它的selector,并组建集合输出。

 

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


   
 汇总数据是询问机制的基本功能,而当集中之前,必须使事先将数据做群组化,才能够进行统计,LINQ
的群组数据功能由Enumerable.GroupBy()函数提供。

     GroupBy()
会按照给定的key(keySelector)同内容(elementSelector),产生群组后底结果(IGroup接口对象或由resultSelector别的结果对象),例:

 1 List<int> sequence =new List<int>(){1,2,3,4,3,2,4,6,4,2,4};
 2  
 3 var group=sequence.GroupBy(o=>o);
 4 foreach(var g in group)
 5 {
 6      Console.WrilteLine("{0} count:{1}",g.Key,g.Count());
 7 /*计算每个数出现的次数。
 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>所做,允许多只键值存在,且一个键值可含蓄多涉嫌的实值。例:

 1 var nameValuesGroup=new[]
 2 {
 3      new{name="Allen", value=65,group="A"},
 4      new{name="Abbey",value=120,group="B"},
 5      new{name="Sue",Value=200,group="A"}
 6 };
 7 var lookupValues=namValuesGroup.ToLookup(c=>c.group);
 8 foreach(var g in lookupValues)
 9 {
10      Console.WriteLine("===Group: {0}===",g.Key);
11      foreach(var item in g)
12      {
13           Console.WriteLine("name:{0},value:{1}",item.name,item.value);
14      }
15 }

 

      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来输出联接的结果。例:

1 var query=from item1 in list1
2      join item2 in list2 on item1 equals item2
3      select item2;
4 var query3=list1.Join(
5      list2,
6      item1=>item1,
7      item2=>item2,
8      (item1,item2)=>item2
9      );

 

     Enumerable<T>.Join()动的是INNER JOIN的概念,当TInner.Key
TOuter.Key一致时,才见面以元素输出及resultSelector 作为参数。

     目前常用的连接模式,INNER JOINEnumerable<T>.Join()
实现,CROSS JOINEnumerable<T>.SelectMany() 实现,还有平等栽JOIN
模式尚未设想,LEFT OUTER JOIN模式,要贯彻此模式,必须要拄GroupJoin()法来促成。

    GroupJoinJoin() 十分相似,不过它们却同时Join()
GroupBy()双方的职能,在Join() 的状下,它见面留给TInner
TOuter零星边都有的值,但以GroupJoin(),它会将TOuter
的价作为Key,并依此来对TInner 做群组化后输出,例:

1 var query4=from item1 in list1
2           join item2 in list2 on item1 equals item2 into g
3           from item in g.DefaultIfEmpty()
4           select new{ v=item1,c=item};
5 var query5=list1.GroupJoin(
6           list2,
7           item1=>item1,
8           item2=>item2,
9           (item1,item2)=>new {v=item1,c=item2.Count()});

 

 

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


     数据排序是于数额处理中广的效益,在LINQ
内的排序主要是为OrderBy函数为主,而为支持连条件的排序,可长ThenBy
函数,以便处理多双重法排序的需。基于LINQ的延迟查询机制,排序也非是于同从头就开展的,而是在数真的给聘时才见面进行排序。因此OrderBy()于处理集合时,传递回来的凡名叫IOrderedEnumerable<T>
接口的目标。

   
 OrderByThenBy再有一个般的道,差别就在于做反而往排序。OrderByDescending
ThenByDescending

     观察函数的原型,会意识OrderBy传扬的是IEnumerable<T>
,但ThenBy传扬的凡IOrderedEnumerable,所以一般以排序时优先调用OrderBy,再使用ThenBy进行多还排序。假设一个集合有A和B两单特性,如果想如果先行为A排序再为B排序,则要下OrderBy(A).ThenBy(B)的主意来进行排序,OrderByThenBy如出一辙不行调用只能设置一个字段,在开展多双重规范时,必须事先调用OrderBy,再依需调用ThenBy同蹩脚或累。例:

 1  var nameValues=new[]
 2 {
 3      new {name="Allen",value=64},
 4      new {name="abbey",value=120},
 5      new {name="slomng",value=330},
 6      new {name="george",value=213}
 7 };
 8 //single sort
 9 var sortedNames=nameValues.OrderBy(c=>c.name);
10 var sortedValues=nameValues.OrderBy(c=>c.value);
11  
12 //multiply sort conditions
13 var sortedByNameValues=nameValues.OrderBy(c=>c.name).ThenBy(c=>c.value);
14 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。例:

1 var arrayOutput=nameValues.ToArray();
2 var listOutput=nameValues.ToList();
3  
4 var dictOutput1=nameValues.ToDictionary(c=>c.name);
5 var dictOutput2=nameValues.ToDictionary(c=>c.name,c=>value);

 

1.7、划分并赢得集合


     Skip()SkipWhile()Take()
TakeWhile()。在数据库查询时,为了达到最佳的性质,在数据量大时要开展分页处理(paging)。上面四独函数的意义就是是以大集合内切出少量数据。

 1 public static IEnumberable<TSource> Skip<TSource>(
 2      this IEnumerable<TSource> source,
 3      int count
 4 )
 5 public static IEnumberable<TSource> SkipWhile<TSource>(
 6      this IEnumerable<TSource> source,
 7      Func<TSource,bool> predicate
 8 )
 9 public static IEnumberable<TSource> SkipWhile<TSource>(
10      this IEnumerable<TSource> source,
11      Func<TSource,int ,bool> predicate
12 )
13 public static IEnumberable<TSource> Take<TSource>(
14      this IEnumerable<TSource> source,
15      int count
16 )
17 public static IEnumberable<TSource> TakeWhile<TSource>(
18      this IEnumerable<TSource> source,
19      Func<TSource,bool> predicate
20 )
21 public static IEnumberable<TSource> TakeWhile<TSource>(
22      this IEnumerable<TSource> source,
23      Func<TSource,int ,bool> predicate
24 )

 

      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
则是扭曲从集合的尾端开始扫描,并回扫描到符合条件的首先独要素。例:

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

 

  LINQ
内还有一个Single,他会见于集聚中独来一个元素时传回该因素,但假如集合是拖欠的可能有一定量单以上之要素时会调用例外处理,或是使用其的姐妹方法SingleOrDefault
传回null值,实用性比fisrt和last 低。

     LINQ
提供了ElementAt()此办法,可遵循索引值访问元素,他生只一般方法ElementAtOrDefault作用和firstordefault/lastordefault
是相同之。当找不至元素时即便赶回回默认值。例:

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

 

      若要一口咬定集合内出没有发出特定值,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),这个种子值会在初始展开演算时作为标准使用,之后只是仍第一蹩脚对种子值的演算方式开做累计运算;第三栽则是以传诵之前做最终的拍卖,例:

 1 double myBalance=100.0;
 2  
 3 int[] withdrawItems={20,10,40,50,10,70,30};
 4  
 5 double balance=withdrawItems.Aggregate(myBalance,(originbalance,nextWithdrawal)=>{
 6      Console.WriteLine("originbalance:{0},nextWithdrawak:{1}",originbalance,nextdrawal);
 7      Console.WriteLine("Withdrawal status:{0}",(nextWithdrawal<=originbalance)?"OK":"FAILED");
 8  
 9      return ((nextWithdrawal<=originbalance)?(originbalance-nextWithdrawal):originbalance);
10 });
11 Console.WriteLine("Ending balance:{0}:",balance);

 

 若要指向终极的储贷值进行拍卖,即可使第三个参数resultSelector,例:

 

1 var balanceStatus=
2 withdrawItems.Aggregate(myBalance,(originbalance,nextWithdrawal)=>{
3      return((nextWithdrawal<=originbalance)?(originbalance-nextWithdrawal):originbalance);
4  
5 },
6 (finalbalance)=>
7 {
8      return (finalbalance>=1000)?"Normal":"Lower";
9 });

 

 

2、标准的查询操作符

 

2.1 筛选


    例:找有得至少15会交锋的碧玺和奥地利赛车手。代码如下:

1 var racers=from r in Formula1.GetChampions()
2           where r.Wins > 15 && (r.Country=="Brazil"||r.Country=="Austria")
3           select r;
4  
5 foreach(var r in racers)
6 {
7      Console.WriteLine("{0:A}",r);
8 }

 

      下面采用Where()  和 Select() 的代码:

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

 

 

2.2 用索引筛选


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

1 var racers=Formula1.GetChamptions().
2           Where((r,index)=>r.LastName.StartsWith("A") && index % 2 !=0);
3  
4 foreach(var r in racers)
5 {
6      Console.WriteLine("{0,A}",r);
7 }
8  

 

2.3 类型筛选


   
 为了拓展基于项目的淘,可以运用OfType扩张方法。这里数组数据包含string
和 int 对象。
使用OfType推而广之方法,把string接近传递让泛型参数,就从集合中回到字符串。

1 object[] data={"ones",1,3,"fre","fdfs",333};
 2 var query=data.OfType<string>();
 3 foreach(var s in query)
 4 {
 5      Console.WriteLine(s);
 6 }
 7  /*
 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 子句被以这些赛车筛选驾驶法拉利的具有冠军。

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

 

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

1 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方法的结果是摊平了赛车手和赛车的层次结构,为每辆赛车返回匿名类型的一个新对象集合。

 

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

 

2.5 排序


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

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

 

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

 

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

 

     使用LINQ
查询时,只待将具备用于排序的例外主要字(用逗号隔开)添加到orderby子句中。在下例中,所有的跑车手先按照国家排序,再按姓氏排序,最后准名字排序。添加到LINQ
查询结果吃的Take()推而广之方法用于取前十独结果:

 

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

 

     使用OrderByThenBy扩大方法可以实施同一之操作

1 var racers=Formula1.GetChamptions().
2      OrderBy(r=>r.Country).
3      ThenBy(r=>r.LastName).
4      ThenBy(r=>r.FirstName).
5      Take(10);

 

 

2.6 分组


     要根据一个主要字值对查询结果分组,可以动用group子句。
现在一级方程式冠军应该遵循国家分组,并列出一个国度之冠军数。子句group r by r.County into g根据
Country 属性组合有的赛车手,并定义一个初的标识符g
它之后用于访问分组的结果信息。group子句的结果当因使用到分组结果达到之恢宏方法Count来排序,如果冠军数一致,就冲重大字排序,该要字是国家,因为马上是分组使用的要字。where
子句子根据至少发生一定量桩的分组来罗结果。select
子句创建一个带来CountryCount特性的匿名类型。

 

 1 var countries= from r in Formula1.GetChampions()
 2                group r by r.Country into g
 3                orderby g.Count() descending, g.Key
 4                where g.Count() >=2
 5                select new {
 6                               Country=g.Key,
 7                               Count=g.Count()
 8                          };
 9 foreach(var item in countries)
10 {
11      Console.WriteLine("{1,-10} {1}",item.Country,item.Count);
12 }

 

     

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

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

 

 

2.7 对嵌套的靶子分组


   
 如果分组的目标应涵盖嵌套的班,就得变动select子句创建的匿名类型。在底下的例证中,所返的国家不仅应包含国家称与赛车手数量就有限只特性,还承诺包含赛车手名序列。这个队列用一个给Racers属性的from/ in
内部子句指定,内部的from
子句以分组标识符g得该分组中之兼具大车手,用百家姓氏对它排序,再依据姓名创建一个新字符串。

     

 1 var countries=from r in Formula1.GetChampions()
 2                group r by r.Country into g
 3                orderby g.Count() descending, g.Key
 4                where g.Count()>=2
 5                select new
 6                {
 7                     Country=g.Key,
 8                     Count=g.Count(),
 9                     Racers=from r1 in g
10                            orderby r1.LastName
11                            select r1.FirstName +" "+ r1.LastName
12                };
13 foreach(var item in countries)
14 {
15      Console.WriteLine("{0,-10} {1}",item.Country,item.Count);
16      foreach(var name in item.Racers)
17      {
18           Console.WriteLine("{0};",name);
19      }
20      Console.WirteLine(); 
21 }

 

 

2.8 内连接


     使用join
子句可以根据特定的尺码合并两只数据源,但前若拿走有限独如连的列表。在一级方程式比赛中,有强车手冠军和车队冠军。赛车手起GetChampions
方法中回到,车队由GetConstructionChampions艺术被回到。现在使博取一个寒暑列表,列有每年的跑车手冠军同车队冠军。

 

 1 var racers= from r in Formula1.GetChampions()
 2             from y in r.Years
 3             select new
 4             {
 5                Year=y,
 6                Name=r.FirstName+" "+r.LastName
 7              };
 8  
 9 vat teams=from t in Formula1.GetConstructorChampions()
10           from y in t.Years
11           select new
12           {
13                Year=y,
14                Name=t.Name
15           };
16 var racersAndTeams=(from r in racers
17                     join t in teams on r.Year equals t.Year
18                     select new
19                     {
20                          r.Year,
21                          Champion=r.Name,
22                          Constructor=t.Name
23                     }).Take(10);
24 Console.WriteLine("Year World Champion\t Constructor Title");
25 foreach(var item in racersAndTeams)
26 {
27      Console.WriteLine("{0}:{1,-20} {2}",item.Year,item.Champion,item.Constructor);
28 }

 

 

     或者统一成一个LINQ 查询

 

 1 var racersAndTeams=(from r in
 2                     from r1 in Formula1.GetChampions()
 3                     from yr in r1.Years
 4                     select new
 5                     {
 6                          Year=yr,
 7                          Name=r1.FirstName+" "+r1.LastName
 8                     }
 9                     join t in
10                          from t1 in Formula1.GetConstructorChampions()
11                          from yt in t1.Years
12                          select new
13                          {
14                               Year=yt,
15                               Name=t1.Name
16                          }
17                     on r.Year equals t.Year
18                     orderby t.Year
19                     select new
20                     {
21                          Year=r.Year,
22                          Racer=r.Name,
23                          Team=t.Name
24                     }).Take(10);

 

 

2.9 左外连接


     上一个连续示例的输出从1958
年起来,因为从这无异于年开始,才又发生了跑车手冠军以及车队冠军。赛车手冠军出现的再早有,是于1950年。使用外连接时,只有找到了配合的笔录才回来结果。为了以结果吃带有有的岁,可以应用左外联接。左外连接返回左边序列中的尽元素,即使其以右侧边的序列中连没有匹配的因素。

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

 

 1 var racersAndTeams=
 2      (from r in racers
 3      join t in teams on r.Year equals t.Year into rt
 4      from t in rt.DefaultIfEmpty()
 5      orderby r.Year
 6      select new
 7      {
 8           Year=r.Year,
 9           Champion=r.Name,
10           Constructor=t==null?"no constructor championship":t.Name
11      }).Take(10);

 

 

2.10 组连接


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

   
 使用组连接时,可以连续不断两个单身的序列,对于其中一个队中的有元素,另一个阵中是对应的一个桩列表。

   
 下面的示范使用了少只单身的阵。一个凡前方例子中早已圈了之冠军列表,另一个凡是一个ChampionShip品种的成团。下面的代码段显示了Championship类。

 

1 public class Championship
2 {
3      public int Year{get;set;}
4      public string First{get;set;}
5      public string Second{get;set;}
6      public string Third{get;set;}
7 }

 

 

GetChampionships 返回了冠军集合

 

 1 private static List<Championship> championships;
 2 public static IEnumerable<Championship> GetChampionships()
 3 {
 4      if(championships == null)
 5      {
 6           championships=new List<Championship>();
 7           championships.Add(new Championship
 8           {
 9                Year=1950,
10                First="Nino Farina",
11                Second="Juan Manuel Fangio",
12                Third="Luigi Fagioli"
13           });
14           championships.Add(new Championship
15           {
16                Year=1951,
17                First="Juan Manuel Fangio",
18                Second="Alberto Ascari",
19                Third="Froliab Gonzalez"
20           });
21      }

 

 

   
 冠军列表应跟每个冠军年份中获取前面三名之跑车手做的列表组合起来,然后显示每一样年之结果。

    RacerInfo仿佛定义了如显得的音讯,如下所示:

1 public class RacerInfo
2 {
3      public int Year{get;set;}
4      public int Position {get;set;}
5      public string FirstName{get;set;}
6      public string LastName{get;set;}
7 }

 

     

     使用连接语句可以拿简单单列表中的赛车手做起来。

   
 因为冠军列表中之各一样码都包含三单赛车手,所以率先要把这个是列表摊平。一种艺术是采用SelectMany
方法,该办法运用的Lambda
表达式为冠军列表中的诸一样起返回包含三宗之一个列表。在是Lambda
表达式的实现中,因为RacerInfo 包含FirstNameLastName
属性,而接受的集纳只含带有First 、Second、Third
属性的一个称谓,所以要拆分字符串,这可由此扩展方法 FirstName
SecondName 完成。

 

 1 var racers=Formula1.GetChampionships()
 2           .SelectMany(cs=>new List<RacerInfo>()
 3           {
 4                new RacerInfo{
 5                     Year=cs.Year,
 6                     Position=1,
 7                     FirstName=cs.First.FirstName(),
 8                     LastName=cs.Last.LastName()
 9                },
10                new RacerInfo{
11                     Year=cs.Year,
12                     Position=2,
13                     FirstName=cs.Fisrt.FirstName(),
14                     LastName=cs.Last.LastName()
15                },
16                new RacerInfo{
17                     Year=cs.Year,
18                     Position=3,
19                     FirstName=cs.First.FirstName(),
20                     LastName=cs.Last.LastName()
21                }
22           });

 

 

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

 

 1 public static class StringExtension
 2 {
 3      public static string FirstName(this string name)
 4      {
 5           int ix=name.LastIndexOf(' ');
 6           return name.Substring(0,ix);
 7      }
 8      public static string LastName(this string name)
 9      {
10           int ix=name.LastIndexOf(' ');
11           return name.Substring(ix+1);
12      }
13 }

 

 

     现在即使好连接两只队。Formula1.GetChampions 返回一个Racers
列表,racers 变量返回包含年、比赛结果和赛车手名字的一个RacerInfo
列表。仅使用姓氏比较单薄个集中之项是不够的。有时候列表中或同时含有了一个胜过车手和外的大人,所以必须同时利用FirstName
LastName
进行比较。这是通过为寡独列表创建一个初的匿名类型实现之。通过采用into
子句,第二单聚众中之结果被填补加到了变量yearResults面临。对于第一只集聚中的各国一个赛车手,都创了一个yearResults.
它涵盖了以第二单集聚中匹配名和姓的结果。最后,用LINQ
查询创建了一个暗含所用信息之初匿名类型。

 

 1 var q=(from r in Formula1.GetChampions()
 2           join r2 in racers on
 3           new
 4           {
 5                FirstName=r.FirstName,
 6                LastName=r.LastName
 7           }
 8           equals
 9           new
10           {
11                FisrtName=r2.FirstName,
12                LastName=r2.LastName
13           }
14           into yearResults
15           select new
16           {
17                FirstName=r.FirstName,
18                LastName=r.LastName,
19                Wins=r.Wins,
20                Stars=r.Stars,
21                Results=yearResults
22           });
23 foreach(var r in q)
24 {
25      Console.WriteLine("{0} {1}",r.FirstName,r.LastName);
26      foreach(var results in r.Results)
27      {
28           Console.WriteLine("{0} {1}.",results.Year,results.Position);
29      }
30 }

 

 

2.11 集聚操作


     扩展方法
DistinctUnionIntersectExcept且是集聚操作。下面创建一个驾法拉利的一级方程式冠军序列及开迈凯伦的一级方程式冠军序列,然后确定是否发开法拉利和迈凯伦的冠军。

 

1 var ferrariDrivers=from r in
2                     Formula1.GetChampions()
3                     from c in r.Cars
4                     where c =="Ferrari"
5                     orderby r.LastName
6                     select r;

 

 

     现在起另一个基本相同的询问,但where
子句的参数不同,以获取有驾驶迈凯伦的冠军。最好不要再编写相同的查询,而得以创造一个道,其中受它们传递参数
car

 

1 private static IEnumerable<Racer> GetRacersByCar(string car)
2 {
3      return from r in Formula1.GetChampions()
4                from c in r.Cars
5                where c==car 
6                orderby r.LastName
7                select r;
8 }

 

 

   
 但是,因为拖欠法无欲重其他地方以,所以\承诺定义一个寄项目的变量来保存LINQ
查询,*racerByCar变量必须是一个寄托项目,该委托类型需要一个字符串参数,并赶回IEnumerable<Racer>,类似于前实现之法门。为夫,定义了几乎独泛型委托Func<>,
所以不待声明自己的寄托。把一个Lambda
表达式赋予racerByCar变量。Lambda 表达式的左侧定义了一个car
变量。其种类时Func 委托的首先单泛型参数(字符串)。右边定义了LINQ
查询,它使该参数和where 子句:

 

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

 

 

     现在好采用Intersect 扩展方法
,获得驾驶法拉利和迈凯伦的有冠军:

     

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

 

     

  集合操作通过调用实体类的GetHashCodeEquals
方法来比较对象。对于自定义比较,还得传递一个落实了IEqualityComparer<T>接口的对象。在是示例中,GetChampions道总是回到相同之对象,因此默认的于操作时有效的,如果不是这种场面,就可重载集合方法来定义比较操作。

 

2.12 合并


    Zip() 方法,允许用一个称为词函数把少单相关的行合并为一个。

   
 首先,创建两独相关的队列,它们以相同之罗和排序方法。对于联合,这十分要紧,因为第一独集聚中的率先码会与亚个聚众中的第一起联合,第一只集聚中之次宗会及第二独集中之老二项联合,以此类推。如果少单班的项数不同,Zip
方法就于抵达比较小集合的结尾时已。

     第一单集中之要素来一个Name属性,第二独集聚中的元素来LastName
和Starts 两个属性

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

 

 1 var racerNames=from r in Formula1.GetChampions()
 2                where r.Country =="Italy"
 3                orderby r.Wins descending
 4                select new
 5                {
 6                     Name=r.FirstName +" "+ r.LastName
 7                };
 8 var racerNamesAndStarts=from r in Formula1.GetChampions()
 9                          where r.Country="Italy"
10                          orderby r.Wins descending
11                          select new
12                          {
13                               LastName=r.LastName,
14                               Starts=r.Starts
15                          };
16 var racers=racerNames.Zip(racerNamesAndStarts,(first,second)=>first.Name+", starts: "+second.Starts);
17 foreach(var r in racers)
18 {
19      Console.WriteLine(r);
20 }

 

 

2.13 分区


     扩展方法Take 和Skip
等之分区操作而用来分页,例如在第一独页面上一味展示5个赛车手,在生一个页面上显得接下去的5只赛车手。

     在底下的LINQ 查询中,把扩大方法Skip 和Take 添加到查询的末梢。Skip
方法先忽略根据页面大小及骨子里页数计算出底项数,再用Take()
方法根据页面大小提取一定数额之宗。

 

1 int pageSize=5;
 2  
 3 int numberPages=(int)Math.Ceiling(Formula1.GetChampions().Count()/(double)pageSize);
 4 for(int page=0;page<numberPages;page++)
 5 {
 6      Console.WriteLine("Page {0}",page);
 7      var racers=(from r in Formula1.GetChampions()
 8                     orderby r.LastName,r.FirstName
 9                     select r.FirstName+" "+r.LastName).
10                     Skip(page*pageSize).Take(pageSize);
11      foreach(var name in racers)
12      {
13           Console.WriteLine(name);
14       }
15      Console.WriteLine();
16 }
17  

 

   
 这个分页机制的一个中心是,因为查询会在每个页面上执行,所以改变底层的数码会潜移默化结果。在继续执行分页操作时,会展示新目标。根据不同之图景,这对于应用程序可能好。如果是操作时莫待之,就足以只针对原来的数据源分页,然后利用映射导到原有数据及的苏存。

     使用TakeWhileSkipWhile
扩展方法,还可以传递一个谓词,根据谓词的结果取或越了一些项。

 

2.14 聚合操作符


     聚合操作符(如 Count、Sum、 Min、Max、Average、Aggregate)
不回来一个行,而回一个价。

    Count扩大方法返回集合中之项数。下面的Count 方法以于Racer 的Year
属性,来筛选赛车手,只回获得冠军次数超过三次等的赛车手,因为同一个询问中得采用及一个计数超过同样坏,所以利用let
子句定义了一个变量 numberYear

 

 1 var query=from r in Formula1.GetChampions()
 2           let numberYears=r.Years.Count()
 3           where numberYear>=3
 4           orderby numberYears descending, r.LastName
 5           select new
 6           {
 7                Name=r.FirstName+" "+r.LastName,
 8                TimesChampion=numberYears
 9           };
10 foreach(var r in query)
11 {
12      Console.WriteLine("{0} {1}",r.Name,r.TimesChampion);
13 }     
14  

 

     Sum 方法汇总序列中之所有数字,返回这些数字之同。下面的Sum
方法用于计算一个国度赢得比赛之到底次数。首先冲国家针对赛车手分组,再在新创办的匿名类型中,把Wins
属性赋予某个国家赢得比赛之终究次数。

 

 1 var countries=(from c in from r in Formula1.GetChampions()
 2                group r by r.Country into c
 3                select new
 4                {
 5                     Country=c.Key,
 6                     Wins=(from r1 in c select r1.Wins).Sum()
 7                }
 8                orderby c.Wins descending, c.Country
 9                select c).Take(5);
10 foreach(var country in countries)
11 {
12      Console.WriteLine("{0} {1}",country.Country,country.Wins);
13 }

 

     对于Aggergate艺术,
可以传递一个Lambda表达式,该表达式对所有的价进行联谊。

 

2.15 转换操作符


   
 前面提到,查询好推到看数项时以尽。在迭代受到动用查询时,查询会执行。而使转换操作符会立即实施查询,把询问结果在数组、列表或字典中。

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

     

1 List<Racer> racers=(from r in Formula1.GetChampions()
2                     where r.Starts>150
3                     orderby r.Starts descending
4                     select r).ToList();
5 foreach(var racer in racers)
6 {
7      Console.WriteLine("{0} {0:S}",racer);
8 }

 

     

   
 把返回的目标在列表中连不曾那粗略。例如,对于集合类中从赛车到高车手之快速访问。可以以新类Lookup<TKey,TElement>

     

  Dictionary<TKey,TValue>
类只支持一个键应和一个价值。在System.Linq名空间的类Lookup<TKey,TElement>好像中,一个键得针对许多单价值。

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

 

 1 var racers=(from r in Formula1.GetChampions()
 2                from c in r.Cars
 3                select new
 4                {
 5                     Car=c,
 6                     Racer=r
 7                }).ToLookup(cr=>cr.Car,cr=>cr.Racer);
 8 if(racers.Contains("Williams"))
 9 {
10      foreach(var williamsRacer in Racers["Williams"])
11      {
12           Console.WriteLine(williamsRacer);
13      }
14 }

 

 

     如果用以非类型化的聚集上(如ArrayList)使用LINQ
查询,就足以以Cast
方法。在下面的事例中,基于Object类型的ArrayList集结用Racer
对象填充。为了定义强类型化的查询,可以应用Cast 方法

 

 1 var list=new System.Collections.ArrayList(Formula1.GetChampions() as System.Collections.ICollection);
 2  
 3 var query= from r in list.Cast<Racer>()
 4           where r.Country=="USA"
 5           orderby r.Wins descending
 6           select r;
 7 foreach(var racer in query)
 8 {
 9      Console.WriteLine("{0:A}",racer);
10 }

 

 

2.16 生成操作符

 

转操作符Range、
Empty、Repear不是扩展方法,而是回到序列的例行静态方法。在LINQ to Objects
中,这些办法可用于Enumerable 类。

      有时需要填一个限制的数字,此时即应承下Range
方法,这个措施把第一单参数作为开场值,把第二独参数作为要填的项数。

1  
2 var values =Enumerable.Range(1,20);
3 foreach(var item in values)
4 {
5      Console.WriteLine("{0}",item);
6 }
7 Console.WriteLine();
8  
9 //结果 1 2 3 4 5 6 ......  19 20

 

 

Range 方法
不归填充了所定义值的集聚,这个主意以及其他方同样,也推迟执行查询,并返一个RangeEnumerator
,其中就来同等长条yield return 语句,来递增值。

 

   
 可以将欠结果与任何扩展方法统一起来,获得任何一个结实。例如,使用Select
扩展方法

 

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

 

 

     Empty
方法返回一个未回去回值的迭代器,他得用于需要一个成团的参数,其中可被参数传递空集合。

     Repeat 方法返回一个迭代器,该迭代器把和一个价更特定的次数。 


相关文章