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

           }
       }