于LINQwhere子句可以合多个表达式。

[TOC]

  本文主要介绍LINQ查询操作符

 

  LINQ查询也极常用之操作符定义了一个声称语法。还有众多询问操作符可用于Enumerable类。

1、LINQ 函数

  下面的例证需要为此到LINQ基础(一)(http://www.cnblogs.com/afei-24/p/6841361.html)的一对代码

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.筛选

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,并组建集合输出。

 

  LINQ查询利用where子句添加条件表达式来罗,where子句可以统一多独表达式。

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()没有。

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

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

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()});

 

 

  上述LINQ表达式映射为C#
LINQ查询的壮大方法:
  var racers =
Formula1.GetChampions().Where(r =>r.Wins>15 &&
    (r.Country == “Brazil” ||
r.Country ==”Austria”)).Select(r => r);

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
所发的底结果。

  注意,并无是为此查询都可以使用LINQ查询语法,也非是有所的扩充方法还映射到LINQ查询。高级查询需要使用扩展方法。

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);

 

2.就此索引筛选

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
在要素满足条件时,就回到该因素或符合一定的索引值条件时返回该因素。

 

  不克下LINQ查询的一个例是Where()方法的重载。在WHere()方法的重载中,可以传递第二单参数————索引。索引是筛选器返回的每个结果的计数器。可以以表达式中运用这个目录,执行因索引的盘算:

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>尽管如此无会见吸引不同处理。

 

var racers = Formula1.GetChampions().
            Where((r, index) => r.LastName.StartsWith("A") && index % 2 != 0);
        foreach (var r in racers)
        {
            Console.WriteLine("{0:A}", r);
        }

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、标准的询问操作符

 

3.类型筛选

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);

 

 

  为了进行基于项目的罗,可以使OfType()扩展方法。

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  

 

object[] data = { "one", 2, 3, "four", "five", 6 };
          var query = data.OfType<string>();
          foreach (var s in query)
          {
            Console.WriteLine(s);
          }

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 */

 

 

  输出:
    one
    four
    five
  从集合仅返回字符串。

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));

 

4.复合的from子句

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);

 

 

  如果要根据目标的分子进行筛,而拖欠成员自身是一个文山会海,就可应用复合from子句子。例如,LINQ基础(一)(http://www.cnblogs.com/afei-24/p/6841361.html)中的Racer类定义了一个属性Cars,Cars是一个字符串数组。

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()});

 

 

  筛选驾驶Ferrari的所以冠军:  

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 }

 

 

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

      foreach (var racer in ferrariDrivers)
      {
        Console.WriteLine(racer);
      }

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);

 

 

  第一单from子句访问Formula1.GetChampions()方法返回的Racer对象,第二独from子句访问Racer类的Cars属性,以回到所以sting类型的赛车。

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 }

 

 

  C#编译器把复合的from子句和LINQ查询转换为SelectMany()扩展方法。SelectMany()扩展方法好迭代序列中之序列。
  SelectMany()的重载版本:
  public static
IEnumerable<TResult> SelectMany<TSource, TCollection,
TResult>(this IEnumerable<TSource> source,
    Func<TSource,
IEnumerable<TCollection>> collectionSelector,
      Func<TSource, TCollection,
TResult> resultSelector);

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方法总是回到相同的靶子,因此默认的较操作时有效的,如果不是这种情形,就可重载集合方法来定义比较操作。

 

  第一单参数是隐式参数,它由Formula1.GetChampions()方法接受Racer对象序列。第二个参数是collectionSelector委托,其中定义了内序列,是行的队列,本例子也Cars。第三单参数为是一个委托,为每个Racer对象的Cars属性的每个元素调用这个委托。

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 }

 

 

  这里Cars是一个字符串数组,会拿每个Racer和每个字符串作为参数,调用这个委托。  

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
扩展方法,还足以传递一个谓词,根据谓词的结果取或跳了一些项。

 

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

        foreach (var racer in ferrariDrivers)
        {
            Console.WriteLine(racer);
        }

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表达式,该表达式对负有的价值进行联谊。

 

5.排序

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 }

 

 

  要指向队列排序,可以行使前使用过的orderby.也得以用orderrby
descending子句(降序)。 

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 方法返回一个迭代器,该迭代器把与一个值更特定的次数。 


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

        foreach (var racer in racers)
        {
            Console.WriteLine("{0}: {1}, {2}", racer.Country, racer.LastName, racer.FirstName);
        }

  orderby子词解析为OrderBy()方法,orderby r.Country
descending解析为OrderByDescending()方法:
  var racers =
Formula1.GetChampions().OrderByDescending(r =>
r.Country).Select(r=>r);

  OrderBy()和OrderByDescending()方法返回IOrderEnumerable<TSource>。这个接口派生自IEnumerable<TSource>接口,但含有一个附加的不二法门CreateOrderEnumerable<TSource>()方法。这个点子用于更被班排序,可以于结尾一个参数指定升序还是降序:
  

// 摘要:
        //     根据某个键对 System.Linq.IOrderedEnumerable<TElement> 的元素执行后续排序。
        //
        // 参数:
        //   keySelector:
        //     用于提取每个元素的键的 System.Func<T,TResult>。
        //
        //   comparer:
        //     用于比较键在返回序列中的位置的 System.Collections.Generic.IComparer<T>。
        //
        //   descending:
        //     如果为 true,则对元素进行降序排序;如果为 false,则对元素进行升序排序。
        //
        // 类型参数:
        //   TKey:
        //     keySelector 生成的键的类型。
        //
        // 返回结果:
        //     一个 System.Linq.IOrderedEnumerable<TElement>,其元素按键排序。
        IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);

  例子:

// Create an array of strings to sort.
              string[] fruits = { "apricot", "orange", "banana", "mango", "apple", "grape", "strawberry" };
              // First sort the strings by their length.
              IOrderedEnumerable<string> sortedFruits2 =
                  fruits.OrderBy(fruit => fruit.Length);
              // Secondarily sort the strings alphabetically, using the default comparer.
              IOrderedEnumerable<string> sortedFruits3 =
                  sortedFruits2.CreateOrderedEnumerable<string>(
                      fruit => fruit,
                      Comparer<string>.Default, false);

  使用ThenBy和ThenByDescending()方法开展更加排序,可以长任意多独:
  var racers =
Formula1.GetChampions().OrderByDescending(r =>
r.Country).ThenByDescending(
    r =>
r.LastName).ThenByDescending(r => r.FirstName).Select(r =>
r);

6.分组

  要因一个要字值对查询结果分组,可以使group子词。

// group r by r.Country into g 根据Country属性组合所有的赛车手,并定义为一个新的集合g,用于访问分组的结果信息。
        //select子句创建一个带Country和Count属性的匿名类型。Country = g.Key Key是r.Country
        var countries = from r in Formula1.GetChampions()
                      group r by r.Country into g
                      orderby g.Count() descending, g.Key
                      where g.Count() >= 2
                      select new
                      {
                        Country = g.Key,
                        Count = g.Count()
                      };
        foreach (var item in countries)
          {
            Console.WriteLine("{0, -10} {1}", item.Country, item.Count);
          }

  输出:

  图片 1

  使用扩展方法执行同样的操作,把group r
by r.Country
子句解析为GroupBy()方法。在GroupBy()方法的宣示遭,它回到实现了IGrouping<TKey,
TSource>接口的枚举对象。IGrouping<TKey,
TSource>接口定义了Key属性,所以于调用了此艺术后,可以看分组的要字:
  public static
IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource,
TKey>(this IEnumerable<TSource> source,
    Func<TSource, TKey>
keySelector);
  使用GroupBy方法:

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

7.对准嵌套的目标分组

  如果博的分组的目标要包含嵌套的阵,就可变更select子句创建匿名类型。
  

//返回的对象不仅需要包含国家名和赛车手这两个属性,还应包含赛车手集合。
        //使用from r1 in g orderby r1.LastName select r1.FirstName + " " + r1.LastName 内部子句
        var countries = from r in Formula1.GetChampions()
                      group r by r.Country into g
                      orderby g.Count() descending, g.Key
                      where g.Count() >= 2
                      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.Write("{0}; ", name);
        }
        Console.WriteLine();
      }

8.内连接

  使用join子句子可以根据特定的尺度合并两独数据源,但前面要获取有限单连续的列表。

  使用了LINQ基础(一)(http://www.cnblogs.com/afei-24/p/6841361.html)的代码  

//GetChampions获得冠军赛车手
        var racers = from r in Formula1.GetChampions()
                   from y in r.Years
                   select new
                   {
                     Year = y,
                     Name = r.FirstName + " " + r.LastName
                   };
        //GetContructorChampions获取冠军车队
          var teams = from t in Formula1.GetContructorChampions()
                      from y in t.Years
                      select new
                      {
                        Year = y,
                        Name = t.Name
                      };
        //得到每一年获得冠军的赛车手和车队
        //通过join t in teams on r.Year equals t.Year into rt 子句连接两个数据源
          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
             });

          Console.WriteLine("Year  Champion\t\t   Constructor Title");
          foreach (var item in racersAndTeams)
          {
            Console.WriteLine("{0}: {1,-20} {2}",
               item.Year, item.Champion, item.Constructor);
          }

 

 

9.左连接
  使用外连返回匹配配r.Year equals
t.Year的结果。左连接返回左边数据源的通元素,即使在右侧边的数码源中没有匹配的因素。
  

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

      var teams = from t in Formula1.GetContructorChampions()
                  from y in t.Years
                  select new
                  {
                    Year = y,
                    Name = t.Name
                  };
        //左连接用join和DefaultIfEmpty方法定义。
        //如果查询到左侧数据源没有和右边数据源Year相同的结果,使用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
         });

      Console.WriteLine("Year  Champion\t\t   Constructor Title");
      foreach (var item in racersAndTeams)
      {
        Console.WriteLine("{0}: {1,-20} {2}",
           item.Year, item.Champion, item.Constructor);
      }

10.组连接

  组连接类似内连,内连通过某个同件连接两只数据源(如 r.Year equals
t.Year),组连接使用同一组项连接,例如下面的例子,
  通过 new
    {
      FirstName =
r.FirstName,
      LastName =
r.LastName
    }
    equals
    new
    {
      FirstName =
r2.FirstName,
      LastName =
r2.LastName
    }
  连接两只数据源
  

var racers = Formula1.GetChampionships()
        .SelectMany(cs => new List<RacerInfo>()
        {
         new RacerInfo {
           Year = cs.Year,
           Position = 1,
           FirstName = cs.First.FirstName(),
           LastName = cs.First.LastName()        
         },
         new RacerInfo {
           Year = cs.Year,
           Position = 2,
           FirstName = cs.Second.FirstName(),
           LastName = cs.Second.LastName()        
         },
         new RacerInfo {
           Year = cs.Year,
           Position = 3,
           FirstName = cs.Third.FirstName(),
           LastName = cs.Third.LastName()        
         }
       });

      var q = (from r in Formula1.GetChampions()
               join r2 in racers on
               new
               {
                 FirstName = r.FirstName,
                 LastName = r.LastName
               }
               equals
               new
               {
                 FirstName = r2.FirstName,
                 LastName = r2.LastName
               }
               into yearResults
               select new
               {
                 FirstName = r.FirstName,
                 LastName = r.LastName,
                 Wins = r.Wins,
                 Starts = r.Starts,
                 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);
        }
      }

 

11.会师操作

  扩展方法Distinct(),Union(),Intersect()(获取交集),Except()都是集聚操作。  

//获取同时驾驶Ferrari和驾驶McLaren获得过冠军的赛车手
        static void SetOperations()
        {
            //定义一个委托,用来查询驾驶Ferrari获得过冠军的赛车手和驾驶McLaren获得过冠军的赛车手
          Func<string, IEnumerable<Racer>> racersByCar =
              car => from r in Formula1.GetChampions()
                     from c in r.Cars
                     where c == car
                     orderby r.LastName
                     select r;

          Console.WriteLine("World champion with Ferrari and McLaren");
          //使用Intersect方法获取两个数据源的交集
          foreach (var racer in racersByCar("Ferrari").Intersect(racersByCar("McLaren")))
          {
            Console.WriteLine(racer);
          }
        }

 

12.合并
  Zip()方法是.NET
4.0初加的,允许用一个也之函数把少单相关的行合并为一个。

  对于联合,第一只集聚中的率先桩与亚个聚众的首先件联合,第一只集中之亚起和第二个集聚的老二宗联合,以此类推。如果简单只序列的项数不同,Zip()方法就会见以达成较小集合的末梢时止。

  第一个聚众中之因素来一个Name属性,第二只集中之元素来LastName和Starts属性。

  以racerNames集合上运Zip()方法,需要将第二个集合racerNamesAndStarts作为第一单参数。第二只参数是一个寄,它通过参数first接受第一个集聚的因素,通过参数second接受第二只集的元素。其促成代码返回一个字符串:  

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);
          }

13.分区

  扩展方法Take()和Skip()等的分区操作而用来分页。

  例如,在首先页才显示5独赛车手,下一致页显示接下去的5只赛车手…
  Skip(page *
pageSize)方法调整至指定索引出,忽略前面的数量。Take(pageSize)方法显示pageSize条数
  

 int pageSize = 5;

          int numberPages = (int)Math.Ceiling(Formula1.GetChampions().Count() /
                (double)pageSize);

          for (int page = 0; 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()方法,传递一个信托,满足这个条件的多寡就是提或跳转:
  public static
IEnumerable<TSource> SkipWhile<TSource>(this
IEnumerable<TSource> source, Func<TSource, bool> predicate);

14.成团操作符

  聚合操作符(如Count(),Sum(),Min(),Max(),Average(),Aggregate())不回来一个列,而是返回一个价值。

  例如,使用Count方法应用于Racer的Years属性,筛选获得冠军次数超过3软的赛车手。因为一再采取r.Years.Count(),所以利用let子词定义了一个变量。  

  

var query = from r in Formula1.GetChampions()
                  let numberYears = r.Years.Count()
                  where numberYears >= 3
                  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);
          }

  Aggregate()方法传递一个寄托,将数据源中的每个元素作为委托的参数,并使指定的函数累加。

15.移操作符

  LINQ基础(一)(http://www.cnblogs.com/afei-24/p/6841361.html)提到,查询会推迟到迭代数量项时才行,使用转换操作符会立即执行查询,把询问结果在数组,列表和字典中。  

    

//转换为数组
        var names = new List<string> { "Nino", "Alberto", "Juan", "Mike", "Phil" };

        var namesWithJ = (from n in names
                         where n.StartsWith("J")
                         orderby n
                         select n).ToList();

  转换为Lookup<TKey,TElement>
  

//把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);
            foreach (var v in racers)
            {
                Console.Write(v.Key+"........");
                foreach (var k in racers[v.Key])
                {
                    Console.WriteLine(k);
                }
            }

  ToLookup(cr => cr.Car, cr =>
cr.Racer)方法的一个重载版本传递一个键以及一个元素选择器

  如果欲以非类型化的联谊上利用LINQ查询,可以采用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);
          }

 

  Cast<Racer>()将
System.Collections.IEnumerable 的素强制转换为指定的类型。

16.生成操作符

  生成操作符Range(),Empty(),Repeat()方法无是扩大方法,而是返回序列的常规静态方法。在LING
to Object中,这些措施可用于Enumerable类。

  Range()方法用来填充一个限量的数字。第一只参数作为开场值,第二独参数作为要填写的项数:
    var values =
Enumerable.Range(1,20);
  结果为1至20的集合。

  可以将该结果跟任何扩展方法统一:
    var values =
Enumerable.Range(1,20).Select(n=> n*3);

  Empty()方法返回一个非回来回值的迭代器,它用于需要一个汇的参数,其中好于参数传递空集合。

  Repeat()方法返回指定个数的重复值的汇聚迭代器。

相关文章