什么是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 Numswhere num > 80select 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 Numswhere num > 80orderby num descendingselect num;
2、如前面的示例所示检索元素的序列,但是将它们转换为新类型的对象。如,查询可以只从数据源中的某些客户记录检索姓氏,或者可以检索完整记录,
IEnumerable<string> queryStr = from num in querywhere num > 80orderby num descendingselect string.Format("The number id {0}", num);
3、检索有关源数据的单独值,如:与特定条件匹配的元素数;具有最大或最小值的元素;与某个条件匹配的第一个元素。如下例子所示:
int hightCount = (from num in Numswhere num > 85select num).Count();
在上面的示例中,在调用Count
方法之前,在查询表达式两边使用了括号,也可以通过使用新变量存储结果,这种写法更具有可读性,因为它使存储查询的变量与存储结果的查询分开,如下例子所示:
IEnumerable<int> hightQuery = from num in Numswhere num > 90select 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 cityListwhere city.Population > 120000select 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 strlet 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 cityListgroup city by city.Population into newCityselect new{Level = newCity.Key,maxKey = (from cityMax in newCityselect cityMax.Population).Max()};
这次就先讲到这里啦,下次在讲解LINQ
的方法语法,热烈欢迎各位广大网友进行批评指正。