LINQ详解(查询表达式)

什么是LINQ？

LINQ(语言集成查询)是将查询功能直接集成到C#中。数据查询表示简单的字符串，在编译时不会进行类型检查和IntelliSense(代码补全辅助工具)支持。

在开发中，通常需要对不同类型的数据源了解不同的查询语句，如SQL数据库、XML文档、各种Web服务等。为了使每种类型的查询语句统一，通过借助LINQ，查询成了最高级的语言构造，就像类、方法、事件一样，可以使用语言关键字和熟悉的运算符针对强类型化对象集合编写查询。LINQ提供了针对对象、关系数据库、XML的查询技术。

LINQ最明显的语言集成部分是查询表达式，查询表达式采用声明性语法编写，可以通过最少的代码对数据源进行筛选、排序和分组等操作，也可以使用相同的基本查询表达模式来查询和转换SQL数据库、ADO.NET数据集、XML文档和流、.NET集合中的数据。

SQL Server数据库、XML文档和流、ADO.NET数据集、支持IEnumerable或泛型IEnumerable<T>接口的任何对象集合都可以使用LINQ查询。
例如：

 //创建数据源
int[] Nums = { 86, 89, 95, 93, 79, 86, 99 };

//定义查询表达式
IEnumerable<int> numQuery = from num in Nums
                            where num > 80
                            select num;
//执行查询
foreach(int num in numQuery)
{
    Console.WriteLine("num={0}", num);
}

查询表达式概述

查询表达式可用于查询并转换所有启用了LINQ的数据源中的数据。如，通过一个查询可以检索数据库中的数据，并生成指定的格式（如XML流）作为输出。

查询表达式容易掌握，因为大部分是熟悉的C#语法。

查询表达式中的变量都是强类型，在大部分情况下，不需要显示提供类型，因为编译器可以进行自行推断出。

只有在循环访问查询变量后，才会执行查询（如foreach语句）。

在编译时，查询表达式根据C#语法规范转换成标准查询运算符方法调用。在查询中，使用的查询语法都可以使用方法语法进行表示。但是，查询语法的可读性更好，更简洁。

在编写LINQ查询时尽量使用查询语法，在必要时使用方法语法。这两种形式在语义或性能上毫无差异，使用查询语法比使用方法语法编写的等同表达式具有更好的可读性。

一次查询操作（如Count或Max）没有等效的查询表达式字句，因此必须表示为方法调用，可以通过各种方式结合使用方法语法和查询语法。

查询表达式可被编译成表达式树或委托，具体应根据查询类型而定。

IEnumerable<T>查询编译为委托。IQueryable和IQueryable<T>查询编译为表达式树。

查询表达式

在进行了解之前，我们首先要思考的是：查询是什么？及其作用是什么？

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

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

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

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

IEnumerable<Country> countryAreaQuery =
from country in countries
where country.Area > 500000
select country;

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

使用select子句可生成所有其它类型的序列，简单的select子句只生成类型与数据源中包含的对象相同对象的类型。如下示例中，数据源中包含Country对象，orderby子句只按新顺序对元素进行排序，select子句生成重新排序的Country对象的序列。

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

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

var queryNameAndPop =
from country in countries
select new { Name = country.Name, Pop = country.Population };

使用group子句可以生成按指定键组织的组的序列，键可以是任意类型的数据。如下示例所示，下面的查询会创建包含一个或多个country对象，并且其键是char值的组的序列。

var queryCountryGroups =
from country in countries
group country by country.Name[0];
foreach(IEnumerable<Country> country in queryCountryGroups )
{
   foreach(Country_country in country )
   {
       Console.WriteLine("City={0}", _country .Name);
   }
}

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

1、检索元素的子集以生成新序列，而不修改各个元素，然后可能以各种方式对返回的序列进行排序或分组。如下所示。

IEnumerable<int> query = from num in Nums
 where num > 80
 orderby num descending
 select num;

2、如前面的示例所示检索元素的序列，但是将它们转换为新类型的对象。如，查询可以只从数据源中的某些客户记录检索姓氏，或者可以检索完整记录，

IEnumerable<string> queryStr = from num in query
 where num > 80
 orderby num descending
 select string.Format("The number id {0}", num);

3、检索有关源数据的单独值，如：与特定条件匹配的元素数；具有最大或最小值的元素；与某个条件匹配的第一个元素。如下例子所示：

 int hightCount = (from num in Nums
 where num > 85
 select num)
 .Count();

在上面的示例中，在调用Count方法之前，在查询表达式两边使用了括号，也可以通过使用新变量存储结果，这种写法更具有可读性，因为它使存储查询的变量与存储结果的查询分开，如下例子所示：

IEnumerable<int> hightQuery = from num in Nums
 where num > 90
 select num;
 int hightCounts = hightQuery.Count();

查询表达式是什么？

查询表达式是以查询语法表示的查询。查询表达式由一组类似于SQL或XQuery的声明性语法所编写的字句组成，每个字句包含一个或多个C#表达式，而这些表达式本身可能是查询表达式或包含查询表达式。

查询表达式必须以from字句开头，且必须以select或group字句结尾。在from和select或group之间，可以包含以下这些可选子句中的一个或多个：where、orderby、join、let，甚至是其它from子句。还可以使用into关键字，使join或group子句的结果可以充当相同查询表达式中的其它查询表达式的源。

查询变量

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

查询变量可以存储采用查询语法、方法语法或两者的组合进行表示的查询，如以下示例中，majorCity 和majorCity2都是查询变量。

List<City> cityList = new List<City>()
            {
 new City{ Population = 1000000},
 new City{Population = 100000},
 new City{Population = 10000},
 new City{Population = 540000}
            };
 //查询语法
 IEnumerable<City> majorCity = from city in cityList
 where city.Population > 120000
 select city;
 //方法语法
 IEnumerable<City> majorCity2 = cityList.Where(a => a.Population > 120000);

另一方面，以下示例演示不是查询变量的变量（即使各自使用查询进行初始化），它们不是查询变量，因为它们存储结果。

int highestScore =
(from score in scores
select score)
.Max();
// or split the expression
IEnumerable<int> scoreQuery =
from score in scores
select score;
int highScore = scoreQuery.Max();
// the following returns the same result
int highScore = scores.Max();
List<City> largeCitiesList =
(from country in countries
from city in country.Cities
where city.Population > 10000
select city)
.ToList();
// or split the expression
IEnumerable<City> largeCitiesQuery =
from country in countries
from city in country.Cities
where city.Population > 10000
select city;
List<City> largeCitiesList2 = largeCitiesQuery.ToList();

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

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

使用into进行延续

可以在select或group子句中使用into关键字创建存储查询的临时标识符。如果在group或select操作之后必须对查询执行其它查询操作，可以使用into关键字。在如下示例中，countries按1000万范围进行分组，创建这些分组之后，附加子句会筛选出一些组，然后按升序对组进行排序，若要执行这些附加操作，需要由countryGroup表示的延续。

var percentileQuery =
from country in countries
let percentile = (int) country.Population / 10000000
group country by percentile into countryGroup
where countryGroup.Key >= 20
orderby countryGroup.Key
select countryGroup;
// grouping is an IGrouping<int, Country>
foreach (var grouping in percentileQuery)
{
Console.WriteLine(grouping.Key);
foreach (var country in grouping)
Console.WriteLine(country.Name + ":" + country.Population);
}

筛选、排序和联接

在开头from子句与结尾select或group子句之间，所有其它子句（where、join、orderby、from、let）都是可选的，任何可选子句在查询中可以使用零次或多次。

where子句

使用where子句可基于一个或多个表达式，从源数据中筛选出元素。如下示例所示。

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

orderby子句

使用orderby子句可按升序或降序对结果进行排序，还可以指定次要排序顺序。如下示例所示，使用Area属性对country对象进行主要排序，Population属性进行次要排序。

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

ascending关键字是可选的，如果未指定任何顺序，则它是默认的排序顺序。

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操作的结果存储到临时变量中来执行分组联接。
let子句
使用let子句可将表达式（如方法调用）的结果存储到新范围变量中。在如下示例中，范围变量f_name存储Split返回的字符串数组中的第一个元素。

            string[] str = { "kdh jsn", "lkhs nhdj", "sjjkd lsmkcj", "shdyfsh sjdnmds" };
            IEnumerable<string> queryName = from name in str
                                            let f_name = name.Split(' ')[0]
                                            select f_name;
            foreach(string name in queryName)
            {
                Console.WriteLine("name={0}", name);
            }

查询表达式中的子查询

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

                           var groupMax = from city in cityList
                           group city by city.Population into newCity
                           select new
                           {
                               Level = newCity.Key,
                               maxKey = (
                                from cityMax in newCity
                                select cityMax.Population
                               ).Max()
                           };

这次就先讲到这里啦，下次在讲解LINQ的方法语法，热烈欢迎各位广大网友进行批评指正。