LINQ 标准的查询操作符 分组 group by into 、select new 、orderby descending、from in

分组

要根据一个关键字值对查询结果分组，可以使用 group  子句。

现在要实现一级方程式冠军应按照国家分组，并列出每个国家的冠军数。

子句 group r by r.Country into g 根据Country 属性组合所有的赛手，并定义一个新的 标识符 g，它以后用于访问分组的结果信息。

group 子句的结果根据应用到分组结果上的扩展方法 Count()来排序，

如果冠军数相同，就根据关键字来排序，该关键字是国家，因为这是分组所使用的关键字。

where  子句根据至少有两项的分组来过滤，

select 子句创建一个带Country  和 Count  属性的匿名类型为结果。

private static void Grouping()

      {

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

          }



      }

 

要用扩展方法执行相同的操作，应把groupby 子句解析为GroupBy()方法。

在GroupBy()方法的声明中，注意它返回实现了IGrouping 接口的对象枚举。

IGrouping 接口定义了Key 属性，所以在定义了对这个方法的调用后，可以访问分组的关键字：

public static IEnumerable < IGrouping < TKey, TSource > > GroupBy < TSource, TKey > (
this IEnumerable < TSource > source, Func < TSource, TKey > keySelector);

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

private static void Grouping()

        {

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



            foreach (var item in countries)

            {

                Console.WriteLine("{0,-10} {1}", item.Country, item.Count);

            }



        }

 

对嵌套的对象分组

 

如果在分组的对象中包含了嵌套的对象，可以通过改变select 子句创建的匿名类型来实现。

在下面的例子中，所创建的国家不仅应包含国家名和赛手数量这两个属性，还包含赛手名序列。

这个序列用一个赋予Racers 属性的 from  in 内部子句指定，

内部的from 子句使用分组标识符g 获得该分组中的所有赛手，用姓氏对它们排序，

再根据姓名创建一个新字符串：

 

private static void GroupingWithNestedObjects()

        {

            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(),

                                //在此之前与前面是一样的，下面是以每个分组结果的g为基础进行排序和查询，好象SQL的嵌套，然后成为匿名对象的一个属性

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

            }

        }

 

 

结果：

第二个嵌套分组的例子和SQL的嵌套结果一样，先通过查询计算出结果后，再进行一次查询

private static void GroupingAndAggregation()

       {

           var countries = from c in

                               from r in Formula1.GetChampions()

                               group r by r.Country into g

                               select new

                               {

                                   Country = g.Key,

                                   Wins = (from x in g

                                           select x.Wins).Sum()  // 注意括号后的调用

                               }//获得的Key和获胜合计两个属性的匿名对象做源

                           orderby c.Wins descending //再进行排序

                           select c;



           foreach (var item in countries)

           {

               Console.WriteLine(item);



           }

       }