C#3.0新增功能07 查询表达式

时间 2019-11-17

标签 c#3.0 新增功能查询表达式栏目 C# 繁體版

原文原文链接

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

查询是什么及其做用是什么

查询是一组指令，描述要从给定数据源（或源）检索的数据以及返回的数据应具备的形状和组织。查询与它生成的结果不一样。html

一般状况下，源数据按逻辑方式组织为相同类型的元素的序列。例如，SQL 数据库表包含行的序列。在 XML 文件中，存在 XML 元素的“序列”（尽管这些元素在树结构按层次结构进行组织）。内存中集合包含对象的序列。数据库

从应用程序的角度来看，原始源数据的特定类型和结构并不重要。应用程序始终将源数据视为 IEnumerable<T> 或 IQueryable<T> 集合。例如在 LINQ to XML 中，源数据显示为 IEnumerable<XElement>。express

对于此源序列，查询可能会执行三种操做之一：编程

检索元素的子集以生成新序列，而不修改各个元素。查询而后可能以各类方式对返回的序列进行排序或分组，以下面的示例所示（假定 scores 是 int[]）：api

IEnumerable<int> highScoresQuery =
    from score in scores
    where score > 80
    orderby score descending
    select score;

如前面的示例所示检索元素的序列，可是将它们转换为新类型的对象。例如，查询能够只从数据源中的某些客户记录检索姓氏。或者能够检索完整记录，而后用于构造其余内存中对象类型甚至是 XML 数据，再生成最终的结果序列。下面的示例演示从 int 到 string 的投影。请注意 highScoresQuery 的新类型。

IEnumerable<string> highScoresQuery2 =
    from score in scores
    where score > 80
    orderby score descending
    select $"The score is {score}";

检索有关源数据的单独值，如：数组

与特定条件匹配的元素数。ide
具备最大或最小值的元素。ui
与某个条件匹配的第一个元素，或指定元素集中特定值的总和。例如，下面的查询从 scores 整数数组返回大于 80 的分数的数量：spa

int highScoreCount =
    (from score in scores
     where score > 80
     select score)
     .Count();

在前面的示例中，请注意在调用 Count 方法以前，在查询表达式两边使用了括号。也能够经过使用新变量存储具体结果，来表示此行为。这种方法更具可读性，由于它使存储查询的变量与存储结果的查询分开。code

IEnumerable<int> highScoresQuery3 =
    from score in scores
    where score > 80
    select score;

int scoreCount = highScoresQuery3.Count();

在上面的示例中，查询在 Count 调用中执行，由于 Count 必须循环访问结果才能肯定 highScoresQuery 返回的元素数。

查询表达式是什么

　　查询表达式是以查询语法表示的查询。查询表达式是一流的语言构造。它如同任何其余表达式同样，能够在 C# 表达式有效的任何上下文中使用。查询表达式由一组用相似于 SQL 或 XQuery 的声明性语法所编写的子句组成。每一个子句进而包含一个或多个 C# 表达式，而这些表达式可能自己是查询表达式或包含查询表达式。

(1)查询表达式必须以 from 子句开头，且必须以 select 或 group 子句结尾。

(2)在第一个 from 子句与最后一个 select 或 group 子句之间，能够包含如下这些可选子句中的一个或多个：where、orderby、join、let，甚至是其余 from 子句。还可使用 into 关键字，使 join 或 group 子句的结果能够充当相同查询表达式中的其余查询子句的源。

查询变量

在 LINQ 中，查询变量是存储查询而不是查询结果的任何变量。更具体地说，查询变量始终是可枚举类型，在 foreach 语句或对其 IEnumerator.MoveNext 方法的直接调用中循环访问时会生成元素序列。

下面的代码示例演示一个简单查询表达式，它具备一个数据源、一个筛选子句、一个排序子句而且不转换源元素。该查询以 select 子句结尾。

static void Main()
{
    // 数据源
    int[] scores = { 90, 71, 82, 93, 75, 82 };

    // 查询表达式
    IEnumerable<int> scoreQuery = // 查询变量
        from score in scores      // 必须
        where score > 80          // 可选
        orderby score descending  // 可选
        select score;             // 必须以 select 或者 group 结尾

    // 执行查询并产生结果
    foreach (int testScore in scoreQuery)
    {
        Console.WriteLine(testScore);
    }                  
}
// 输出: 93 90 82 82

在上面的示例中，scoreQuery 是查询变量，它有时仅仅称为查询。查询变量不存储在 foreach 循环生成中的任何实际结果数据。而且当 foreach 语句执行时，查询结果不会经过查询变量 scoreQuery 返回。而是经过迭代变量 testScore 返回。 scoreQuery 变量能够在另外一个 foreach 循环中进行循环访问。只要既没有修改它，也没有修改数据源，便会生成相同结果。

查询变量能够存储采用查询语法、方法语法或是二者的组合进行表示的查询。在如下示例中，queryMajorCities 和 queryMajorCities2 都是查询变量：

var cities = new City
{
  new city(){Name = "上海",Population = 24180000},
  new city(){Name = "南京",Population = 8436200},
  new city(){Name = "北京",Population = 21710000},
  new city(){Name = "广州",Population = 14900000}
};

// 查询语法
IEnumerable<City> queryMajorCities =
    from city in cities
    where city.Population > 100000
    select city;

// 基于方法的语法
IEnumerable<City> queryMajorCities2 = cities.Where(c => c.Population > 100000);

另外一方面，如下两个示例演示不是查询变量的变量（即便各自使用查询进行初始化）。它们不是查询变量，由于它们存储结果：

int highestScore =
    (from score in scores
     select score)
    .Max();

// 或者拆分表达式
IEnumerable<int> scoreQuery =
    from score in scores
    select score;

int highScore = scoreQuery.Max();
// 下面的表达式返回相同的结果
int highScore = scores.Max();

List<City> largeCitiesList =
    (from country in countries
     from city in country.Cities
     where city.Population > 10000
     select city)
       .ToList();

// 或者拆分表达式
IEnumerable<City> largeCitiesQuery =
    from country in countries
    from city in country.Cities
    where city.Population > 10000
    select city;

List<City> largeCitiesList2 = largeCitiesQuery.ToList();

有关表示查询的不一样方式的详细信息，请参阅 LINQ 中的查询语法和方法语法。

查询变量的显式和隐式类型化

本文档一般提供查询变量的显式类型以便显示查询变量与 select 子句之间的类型关系。可是，还可使用 var 关键字指示编译器在编译时推断查询变量（或任何其余局部变量）的类型。例如，本主题中前面演示的查询示例也可使用隐式类型化进行表示：

// 在这里和全部查询中使用var都是可选的。querycities是一个IEnumerable<city>就像它是显式类型同样
var queryCities =
    from city in cities
    where city.Population > 100000
    select city;

有关详细信息，请参阅隐式类型化局部变量和 LINQ 查询操做中的类型关系。

开始查询表达式

查询表达式必须以 from 子句开头。它指定数据源以及范围变量。范围变量表示遍历源序列时，源序列中的每一个连续元素。范围变量基于数据源中元素的类型进行强类型化。在下面的示例中，由于 countries 是 Country 对象的数组，因此范围变量也类型化为 Country。由于范围变量是强类型，因此可使用点运算符访问该类型的任何可用成员。

IEnumerable<Country> countryAreaQuery =
    from country in countries
    where country.Area > 500000 //面积大于500000
    select country;

范围变量一直处于范围中，直到查询使用分号或 continuation 子句退出。

查询表达式可能会包含多个 from 子句。在源序列中的每一个元素自己是集合或包含集合时，可以使用其余 from 子句。例如，假设具备 Country 对象的集合，其中每一个对象都包含名为 Cities 的 City 对象集合。若要查询每一个 Country 中的 City 对象，请使用两个 from 子句，以下所示：

IEnumerable<City> cityQuery =
    from country in countries
    from city in country.Cities
    where city.Population > 10000
    select city;

有关详细信息，请参阅 from 子句。

结束查询表达式

查询表达式必须以 group 子句或 select 子句结尾。

group 子句

使用 group 子句可生成按指定键组织的组的序列。键能够是任何数据类型。例如，下面的查询会建立包含一个或多个 Country 对象而且其键是 char 值的组的序列。

var queryCountryGroups =
    from country in countries
    group country by country.Name[0];

有关分组的详细信息，请参阅 group 子句。

select 子句

使用 select 子句可生成全部其余类型的序列。简单 select 子句只生成类型与数据源中包含的对象相同的对象的序列。在此示例中，数据源包含 Country 对象。 orderby 子句只按新顺序对元素进行排序，而 select 子句生成从新排序的 Country 对象的序列。

IEnumerable<Country> sortedQuery =
    from country in countries
    orderby country.Area
    select country;

select 子句能够用于将源数据转换为新类型的序列。此转换也称为投影。在下面的示例中，select 子句对只包含原始元素中的字段子集的匿名类型序列进行投影。请注意，新对象使用对象初始值设定项进行初始化。

// 此处 var 是必须的，由于查询返回了匿名类型
var queryNameAndPop =
    from country in countries
    select new { Name = country.Name, Pop = country.Population };

有关可使用 select 子句转换源数据的全部方法的详细信息，请参阅 select 子句。

使用“into”进行延续

能够在 select 或 group 子句中使用 into 关键字建立存储查询的临时标识符。若是在分组或选择操做以后必须对查询执行其余查询操做，则能够这样作。在下面的示例中，countries 按 1000 万范围，根据人口进行分组。建立这些组以后，附加子句会筛选出一些组，而后按升序对组进行排序。若要执行这些附加操做，须要由 countryGroup 表示的延续。

// 该查询返回的类型是 IEnumerable<IGrouping<int, Country>>
var percentileQuery =
    from country in countries
    let percentile = (int) country.Population / 10_000_000
    group country by percentile into countryGroup
    where countryGroup.Key >= 20
    orderby countryGroup.Key
    select countryGroup;

// 分组是 IGrouping<int, Country>
foreach (var grouping in percentileQuery)
{
    Console.WriteLine(grouping.Key);
    foreach (var country in grouping)
        Console.WriteLine(country.Name + ":" + country.Population);
}

有关详细信息，请参阅 into。

筛选、排序和联接

在开头 from 子句与结尾 select 或 group 子句之间，全部其余子句（where、join、orderby、from、let）都是可选的。任何可选子句均可以在查询正文中使用零次或屡次。

IEnumerable<City> queryCityPop =
    from city in cities
    where city.Population < 200000 && city.Population > 100000
    select city;

有关详细信息，请参阅 where 子句。

orderby 子句

使用 orderby 子句可按升序或降序对结果进行排序。还能够指定次要排序顺序。下面的示例使用 Area 属性对 country 对象执行主要排序。而后使用 Population 属性执行次要排序。

IEnumerable<Country> querySortedCountries =
    from country in countries
    orderby country.Area, country.Population descending
    select country;

ascending 关键字是可选的；若是未指定任何顺序，则它是默认排序顺序。有关详细信息，请参阅 orderby 子句。

join 子句

使用 join 子句可基于每一个元素中指定的键之间的相等比较，将一个数据源中的元素与另外一个数据源中的元素进行关联和/或合并。在 LINQ 中，联接操做是对元素属于不一样类型的对象序列执行。联接了两个序列以后，必须使用 select 或 group 语句指定要存储在输出序列中的元素。还可使用匿名类型将每组关联元素中的属性合并到输出序列的新类型中。下面的示例关联其 Category 属性与 categories 字符串数组中一个类别匹配的 prod 对象。筛选出其 Category 不与 categories 中的任何字符串匹配的产品。select 语句会投影其属性取自 cat 和 prod 的新类型。

var categoryQuery =
    from cat in categories
    join prod in products on cat equals prod.Category
    select new { Category = cat, Name = prod.Name };

还能够经过使用 into 关键字将 join 操做的结果存储到临时变量中来执行分组联接。有关详细信息，请参阅 join 子句。

let 子句

使用 let 子句可将表达式（如方法调用）的结果存储在新范围变量中。在下面的示例中，范围变量 firstName 存储 Split 返回的字符串数组的第一个元素。

string[] names = { "Svetlana Omelchenko", "Claire O'Donnell", "Sven Mortensen", "Cesar Garcia" };
IEnumerable<string> queryFirstNames =
    from name in names
    let firstName = name.Split(' ')[0]
    select firstName;

foreach (string s in queryFirstNames)
     Console.Write(s + " ");

//输出: Svetlana Claire Sven Cesar

有关详细信息，请参阅 let 子句。

查询表达式中的子查询

查询子句自己可能包含查询表达式，这有时称为子查询。每一个子查询都以本身的 from 子句开头，该子句不必定指向第一个 from 子句中的相同数据源。例如，下面的查询演示在 select 语句用于检索分组操做结果的查询表达式。

var queryGroupMax =
    from student in students
    group student by student.GradeLevel into studentGroup
    select new
    {
        Level = studentGroup.Key,
        HighestScore =
            (from student2 in studentGroup
             select student2.Scores.Average())
             .Max()
    };

有关详细信息，请参阅如何：对分组操做执行子查询。

其余技术请参阅

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