C#3.0新增功能09 LINQ 标准查询运算符 04 运算

系列目录    【已更新最新开发文章，点击查看详细】

本篇主要介绍标准查询运算符的常用运算功能。

01 对数据排序

排序操作基于一个或多个属性对序列的元素进行排序。 第一个排序条件对元素执行主要排序。 通过指定第二个排序条件，您可以对每个主要排序组内的元素进行排序。

下图展示了对一系列字符执行按字母顺序排序操作的结果。

下节列出了对数据进行排序的标准查询运算符方法。

方法

查询表达式语法示例

主要排序示例

主要升序排序

下面的示例演示如何在 LINQ 查询中使用 orderby 子句按字符串长度对数组中的字符串进行升序排序。

string[] words = { "the", "quick", "brown", "fox", "jumps" };  IEnumerable<string> query = from word in words
                            orderby word.Length
                            select word;  foreach (string str in query)
    Console.WriteLine(str);  /* 输出:
    the
    fox
    quick
    brown
    jumps
*/

主要降序排序

下面的示例演示如何在 LINQ 查询中使用 orderby descending 子句按字符串的第一个字母对字符串进行降序排序。

string[] words = { "the", "quick", "brown", "fox", "jumps" };  IEnumerable<string> query = from word in words
                            orderby word.Substring(, ) descending
                            select word;  foreach (string str in query)
    Console.WriteLine(str);  /*  输出：
    the
    quick
    jumps
    fox
    brown
*/

次要排序示例

次要升序排序

下面的示例演示如何在 LINQ 查询中使用 orderby 子句对数组中的字符串执行主要和次要排序。 首先按字符串长度，其次按字符串的第一个字母，对字符串进行升序排序。

string[] words = { "the", "quick", "brown", "fox", "jumps" };  IEnumerable<string> query = from word in words
                            orderby word.Length, word.Substring(, )
                            select word;  foreach (string str in query)
    Console.WriteLine(str);  /* 输出：
    fox
    the
    brown
    jumps
    quick
*/

次要降序排序

下面的示例演示如何在 LINQ 查询中使用 orderby descending 子句按升序执行主要排序，按降序执行次要排序。 首先按字符串长度，其次按字符串的第一个字母，对字符串进行排序。

string[] words = { "the", "quick", "brown", "fox", "jumps" };  IEnumerable<string> query = from word in words
                            orderby word.Length, word.Substring(, ) descending
                            select word;  foreach (string str in query)
    Console.WriteLine(str);  /* 输出：
    the
    fox
    quick
    jumps
    brown
*/

02 Set(集)运算

LINQ 中的集运算是指根据相同或不同集合（或集）中是否存在等效元素来生成结果集的查询运算。

下节列出了执行集运算的标准查询运算符方法。

方法

比较集运算

Distinct

下图演示字符序列上 Enumerable.Distinct 方法的行为。 返回的序列包含输入序列的唯一元素。

Except

下图演示 Enumerable.Except 的行为。 返回的序列只包含位于第一个输入序列但不位于第二个输入序列的元素。

相交

下图演示 Enumerable.Intersect 的行为。 返回的序列包含两个输入序列共有的元素。

联合

下图演示对两个字符序列执行的联合操作。 返回的序列包含两个输入序列的唯一元素。

03 筛选数据

筛选是指将结果集限制为仅包含满足指定条件的元素的操作。 它也称为选定内容。

下图演示了对字符序列进行筛选的结果。 筛选操作的谓词指定字符必须为“A”。

下面一节列出了执行所选内容的标准查询运算符方法。

方法

查询表达式语法示例

以下示例使用 where 子句从数组中筛选具有特定长度的字符串。

string[] words = { "the", "quick", "brown", "fox", "jumps" };  IEnumerable<string> query = from word in words
                            where word.Length ==
                            select word;  foreach (string str in query)
    Console.WriteLine(str);  /* 输出：
    the
    fox
*/

04 限定符运算

限定符运算返回一个 Boolean 值，该值指示序列中是否有一些元素满足条件或是否所有元素都满足条件。

下图描述了两个不同源序列上的两个不同限定符运算。 第一个运算询问是否有一个或多个元素为字符“A”，结果为 true。 第二个运算询问是否所有元素都为字符“A”，结果为 true。

下节列出了执行限定符运算的标准查询运算符方法。

方法

 05 投影运算

投影是指将对象转换为一种新形式的操作，该形式通常只包含那些将随后使用的属性。 通过使用投影，您可以构造从每个对象生成的新类型。 可以投影属性，并对该属性执行数学函数。 还可以在不更改原始对象的情况下投影该对象。

下面一节列出了执行投影的标准查询运算符方法。

方法

查询表达式语法示例

选择

下面的示例使用 select 子句来投影字符串列表中每个字符串的第一个字母。

List<string> words = new List<string>() { "an", "apple", "a", "day" };  var query = from word in words
            select word.Substring(, );  foreach (string s in query)
    Console.WriteLine(s);  /* 输出：
    a
    a
    a
    d
*/

SelectMany

下面的示例使用多个 from 子句来投影字符串列表中每个字符串中的每个单词。

List<string> phrases = new List<string>() { "an apple a day", "the quick brown fox" };  var query = from phrase in phrases
            from word in phrase.Split(' ')
            select word;  foreach (string s in query)
    Console.WriteLine(s);  /* 输出：
    an
    apple
    a
    day
    the
    quick
    brown
    fox
*/

Select 与 SelectMany

Select() 和 SelectMany() 的工作都是依据源值生成一个或多个结果值。 Select() 为每个源值生成一个结果值。 因此，总体结果是一个与源集合具有相同元素数目的集合。 与之相反，SelectMany() 生成单个总体结果，其中包含来自每个源值的串联子集合。 作为参数传递到 SelectMany() 的转换函数必须为每个源值返回一个可枚举值序列。 然后，SelectMany() 串联这些可枚举序列，以创建一个大的序列。

下面两个插图演示了这两个方法的操作之间的概念性区别。 在每种情况下，假定选择器（转换）函数从每个源值中选择一个由花卉数据组成的数组。

下图描述 Select() 如何返回一个与源集合具有相同元素数目的集合。

下图描述 SelectMany() 如何将中间数组序列串联为一个最终结果值，其中包含每个中间数组中的每个值。

代码示例

下面的示例比较 Select() 和 SelectMany() 的行为。 代码通过从源集合的每个花卉名称列表中提取前两项来创建一个“花束”。 此示例中，transform 函数 Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) 使用的“单值”本身即是值的集合。 这需要额外的 foreach 循环，以便枚举每个子序列中的每个字符串。

 class Bouquet
 {
     public List<string> Flowers { get; set; }
 }   static void SelectVsSelectMany()
 {
     List<Bouquet> bouquets = new List<Bouquet>() {
         new Bouquet { Flowers = new List<string> { "sunflower", "daisy", "daffodil", "larkspur" }},
         new Bouquet { Flowers = new List<string> { "tulip", "rose", "orchid" }},
         new Bouquet { Flowers = new List<string> { "gladiolis", "lily", "snapdragon", "aster", "protea" }},
         new Bouquet { Flowers = new List<string> { "larkspur", "lilac", "iris", "dahlia" }}
     };       // *********** Select ***********
     IEnumerable<List<string>> query1 = bouquets.Select(bq => bq.Flowers);       // ********* SelectMany *********
     IEnumerable<string> query2 = bouquets.SelectMany(bq => bq.Flowers);       Console.WriteLine("Results by using Select():");
     // 注意这里额外的foreach循环
     foreach (IEnumerable<String> collection in query1)
         foreach (string item in collection)
             Console.WriteLine(item);       Console.WriteLine("\nResults by using SelectMany():");
     foreach (string item in query2)
         Console.WriteLine(item);       /* 输出：        Results by using Select():
         sunflower
         daisy
         daffodil
         larkspur
         tulip
         rose
         orchid
         gladiolis
         lily
         snapdragon
         aster
         protea
         larkspur
         lilac
         iris
         dahlia          Results by using SelectMany():
         sunflower
         daisy
         daffodil
         larkspur
         tulip
         rose
         orchid
         gladiolis
         lily
         snapdragon
         aster
         protea
         larkspur
         lilac
         iris
         dahlia
     */   }

06 数据分区

LINQ 中的分区是指将输入序列划分为两个部分的操作，无需重新排列元素，然后返回其中一个部分。

下图显示对字符序列进行三种不同的分区操作的结果。 第一个操作返回序列中的前三个元素。 第二个操作跳过前三个元素，返回剩余元素。 第三个操作跳过序列中的前两个元素，返回接下来的三个元素。

下面一节列出了对序列进行分区的标准查询运算符方法。

运算符

 07 联接运算

联接两个数据源就是将一个数据源中的对象与另一个数据源中具有相同公共属性的对象相关联。

当查询所面向的数据源相互之间具有无法直接领会的关系时，联接就成为一项重要的运算。在面向对象的编程中，这可能意味着在未建模对象之间进行关联，例如对单向关系进行反向推理。 下面是单向关系的一个示例：Customer 类有一个类型为 City 的属性，但 City 类没有作为 Customer 对象集合的属性。 如果你具有一个 City 对象列表，并且要查找每个城市中的所有客户，则可以使用联接运算完成此项查找。

LINQ 框架中提供的 join 方法包括 Join 和 GroupJoin。 这些方法执行同等联接，即根据 2 个数据源的键是否相等来匹配这 2 个数据源的联接。 （与此相较，Transact-SQL 支持除“等于”之外的联接运算符，例如“小于”运算符。）用关系数据库术语表达，就是说 Join 实现了内部联接，这种联接只返回那些在另一个数据集中具有匹配项的对象。 GroupJoin 方法在关系数据库术语中没有直接等效项，但实现了内部联接和左外部联接的超集。 左外部联接是指返回第一个（左侧）数据源的每个元素的联接，即使其他数据源中没有关联元素。

下图显示了一个概念性视图，其中包含两个集合以及这两个集合中的包含在内部联接或左外部联接中的元素。

方法

其他技术请参阅

• System.Linq
• 标准查询运算符概述 (C#)
• 匿名类型
• 构建联接和叉积查询
• join 子句
• 如何：使用组合键进行联接
• 如何：联接不同文件的内容 (LINQ) (C#)
• 如何：对 join 子句的结果进行排序
• 如何：执行自定义联接操作
• 如何：执行分组联接
• 如何：执行内部联接
• 如何：执行左外部联接
• 如何：从多个源填充对象集合 (LINQ) (C#)

 08 数据分组

分组是指将数据分到不同的组，使每组中的元素拥有公共的属性。

下图演示了对字符序列进行分组的结果。 每个组的键是字符。

下一节列出了对数据元素进行分组的标准查询运算符方法。

方法

查询表达式语法示例

下列代码示例根据奇偶性，使用 group by 子句对列表中的整数进行分组。

List<int> numbers = new List<int>() { , , , , , , , , ,  };  IEnumerable<IGrouping<int, int>> query = from number in numbers
                                         group number by number % ;  foreach (var group in query)
{
    Console.WriteLine(group.Key ==  ? "\nEven numbers:" : "\nOdd numbers:");
    foreach (int i in group)
        Console.WriteLine(i);
}  /*  输出：
    Odd numbers:
    35
    3987
    199
    329      Even numbers:
    44
    200
    84
    4
    446
    208
*/

其他技术请参阅

• System.Linq
• 标准查询运算符概述 (C#)
• group 子句
• 如何：创建嵌套组
• 如何：按扩展名对文件进行分组 (LINQ) (C#)
• 如何：对查询结果进行分组
• 如何：对分组操作执行子查询
• 如何：使用组将一个文件拆分成多个文件 (LINQ) (C#)

09 生成运算

生成是指创建新的值序列。

下面一节列出了执行生成的标准查询运算符方法。

方法

 10 相等运算

两个序列，其相应元素相等且具有被视为相等的相同数量的元素。

方法

 11 元素运算

元素运算从序列中返回唯一、特定的元素。

下节列出了执行元素运算的标准查询运算符方法。

方法

 12 数据类型转换

转换方法可更改输入对象的类型。

LINQ 查询中的转换运算可用于各种应用程序。 以下是一些示例：

• Enumerable.AsEnumerable 方法可用于隐藏类型的标准查询运算符自定义实现。

• Enumerable.OfType 方法可用于为 LINQ 查询启用非参数化集合。

• Enumerable.ToArray、Enumerable.ToDictionary、Enumerable.ToList 和 Enumerable.ToLookup方法可用于强制执行即时的查询，而不是将其推迟到枚举该查询时。

方法

下表列出了执行数据类型转换的标准查询运算符方法。

本表中名称以“As”开头的转换方法可更改源集合的静态类型，但不对其进行枚举。 名称以“To”开头的方法可枚举源集合，并将项放入相应的集合类型。

查询表达式语法示例

下面的代码示例使用显式类型化的范围变量将类型转换为子类型，然后才访问仅在此子类型上可用的成员。

 class Plant
 {
     public string Name { get; set; }
 }   class CarnivorousPlant : Plant
 {
     public string TrapType { get; set; }
 }   static void Cast()
 {
     Plant[] plants = new Plant[] {
         new CarnivorousPlant { Name = "Venus Fly Trap", TrapType = "Snap Trap" },
         new CarnivorousPlant { Name = "Pitcher Plant", TrapType = "Pitfall Trap" },
         new CarnivorousPlant { Name = "Sundew", TrapType = "Flypaper Trap" },
         new CarnivorousPlant { Name = "Waterwheel Plant", TrapType = "Snap Trap" }
     };       var query = from CarnivorousPlant cPlant in plants
                 where cPlant.TrapType == "Snap Trap"
                 select cPlant;       foreach (Plant plant in query)
         Console.WriteLine(plant.Name);       /* 输出：         Venus Fly Trap
         Waterwheel Plant
     */
 }

13 串联运算

串联是指将一个序列附加到另一个序列的操作。

下图描绘了两个字符序列的串联操作。

下面一节列出了执行串联的标准查询运算符方法。

方法

 14 聚合运算

聚合运算从值的集合中计算出单个值。 例如，从一个月累计的每日温度值计算出日平均温度值就是一个聚合运算。

下图显示对数字序列进行两种不同聚合操作所得结果。 第一个操作累加数字。 第二个操作返回序列中的最大值。

下节列出了执行聚合运算的标准查询运算符方法。

方法

 系列目录    【已更新最新开发文章，点击查看详细】