【C#】LINQ
一、什么是LINQ
长期以来，开发社区形成以下的格局：
1、面向对象与数据访问两个领域长期分裂，各自为政。
2、编程语言中的数据类型与数据库中的数据类型形成两套不同的体系，例如：
C#中字符串用string数据类型表示。
SQL中字符串用NVarchar/Varchar/Char数据类型表示。
3、SQL编码体验落后
没有智能感知效果。
没有严格意义上的强类型和类型检查。
4、SQL和XML都有各自的查询语言，而对象没有自己的查询语言。
上面描述的问题，都可以使用LINQ解决，那么究竟什么是LINQ呢？
LINQ（Language Integrated Query）即语言集成查询。
LINQ是一组语言特性和API，使得你可以使用统一的方式编写各种查询。用于保存和检索来自不同数据源的数据，从而消除了编程语言和数据库之间的不匹配，以及为不同类型的数据源提供单个查询接口。
LINQ总是使用对象，因此你可以使用相同的查询语法来查询和转换XML、对象集合、SQL数据库、ADO.NET数据集以及任何其他可用的LINQ提供程序格式的数据。
LINQ主要包含以下三部分：
1、LINQ to Objects 主要负责对象的查询。
2、LINQ to XML 主要负责XML的查询。
3、LINQ to ADO.NET 主要负责数据库的查询。
LINQ to SQL
LINQ to DataSet
LINQ to Entities
LINQ教程二：LINQ操作语法
LINQ查询时有两种语法可供选择：查询表达式语法（Query Expression）和方法语法（Fluent Syntax）。
一、查询表达式语法
查询表达式语法是一种更接近SQL语法的查询方式。
LINQ查询表达式语法如下：
1 from<range variable> in <IEnumerable<T> or IQueryable<T> Collection>
2 <Standard Query Operators> <lambda expression>
3 <select or groupBy operator> <result formation>
LINQ查询表达式
| 约束 | LINQ查询表达式必须以from子句开头，以select或group子句介绍 |
| 关键字 | 功能 |
| from....in... |
指定要查询的数据源以及范围变量，多个from子句则表示从多个数据源查找数据。注意：C#编译器会把“复合from子句”的查询表达式转换为SelectMany()扩展方法。 |
| join…in…on…equals… | 指定多个数据源的关联方式 |
| let | 引入用于存储查询表达式中子表达式结果的范围变量。通常能达到层次感会更好，使代码更易于阅读。 |
| orderby、descending | 指定元素的排序字段和排序方式。当有多个排序字段时，由字段顺序确定主次关系，可指定升序和降序两种排序方式 |
| where | 指定元素的筛选条件。多个where子句则表示了并列条件，必须全部都满足才能入选。每个where子句可以使用谓词&&、||连接多个条件表达式。 |
| group | 指定元素的分组字段。 |
| select | 指定查询要返回的目标数据，可以指定任何类型，甚至是匿名类型。（目前通常被指定为匿名类型） |
| into | 提供一个临时的标识符。该标识可以引用join、group和select子句的结果。 1) 直接出现在join子句之后的into关键字会被翻译为GroupJoin。（into之前的查询变量可以继续使用） 2) select或group子句之后的into它会重新开始一个查询，让我们可以继续引入where, orderby和select子句，它是对分步构建查询表达式的一种简写方式。（into之前的查询变量都不可再使用） |
查询语法从一个From子句开始，然后是一个Range变量。 From子句的结构类似于“From rangeVariableName in IEnumerablecollection”。 在英语中，这意味着，从集合中的每个对象。 它类似于foreach循环：foreach（student in studentList）。
在From子句之后，您可以使用不同的标准查询运算符来过滤，分组，连接集合的元素。 LINQ中有大约50个标准查询运算符。标准查询运算符后面通常跟一个条件，这个条件通常使用lambda表达式来表示。
LINQ查询语法总是以Select或Group子句结束。 Select子句用于对数据进行整形。 您可以选择整个对象，因为它是或只有它的一些属性。 在上面的例子中，我们选择了每个结果字符串元素。
例如：我们要从数组中查询出偶数，查询表达式示例代码如下：
var result = from p in ints where p % 2 == 0 select p;
查询表达式语法要点总结：
1、查询表达式语法与SQL（结构查询语言）语法相同。
2、查询语法必须以from子句开头，可以以Select或GroupBy子句结束 。
3、使用各种其他操作，如过滤，连接，分组，排序运算符以构造所需的结果。
4、隐式类型变量 - var可以用于保存LINQ查询的结果。
二、方法语法
方法语法（也称为流利语法）主要利用System.Linq.Enumerable类中定义的扩展方法和Lambda表达式方式进行查询，类似于如何调用任何类的扩展方法。
以下是一个示例LINQ方法语法的查询，返回数组中的偶数：
var result = ints.Where(p => p % 2 == 0).ToArray();
从上面的示例代码中可以看出：方法语法包括扩展方法和Lambda表达式。 扩展方法Where（）在Enumerable类中定义。
如果你检查Where扩展方法的签名，你会发现Where方法接受一个谓词委托，如Func <Student，bool>。 这意味着您可以传递任何接受Student对象作为输入参数的委托函数，并返回一个布尔值，如下图所示。 lambda表达式作为在Where子句中传递的委托传递。 在下一节中学习lambda表达式。
三、查询表达式语法VS方法语法
查询表达式语法与方法语法存在着紧密的关系
1、CLR本身并不理解查询表达式语法，它只理解方法语法。
2、编译器负责在编译时将查询表达式语法翻译为方法语法。
3、大部分方法语法都有对应的查询表达式语法形式：如Select()对应select、OrderBy()对应orderby
4、部分查询方法目前在C#中还没有对应的查询语句：如Count()和Max()，这是只能采用以下替代方案：
方法语法
查询表达式语法+方法语法的混合方式
LINQ教程三：Lambda表达式解剖
C#3.0（.NET3.5）中引入了Lambda表达式和LINQ。Lambda表达式是使用一些特殊语法表示匿名方法的较短方法。
最基本的Lambda表达式语法如下：
（参数列表）=>{方法体}
说明：
1、参数列表中的参数类型可以是明确类型或者推断类型。
2、如果是推断类型，则参数的数据类型将由编辑器根据上下文自动推断出来。
让我们看看Lambda表达式是如何从匿名方法演变而来的。
相关示例：
1 delegate(int item) { return item % 2 == 0; };
1、Lambda表达式从匿名方法演变，首先删除delegate关键字和参数类型并添加Lambda运算符=>，演变后的代码如下：
1 (item)=>{return item % 2 == 0;};
2、如果我们只有一个返回值的语句，那么我们不需要花括号、返回和分号，所以我们可以去掉这些符号，演变后的代码如下：
1 (item)=>item %2 == 0;
3、如果我们只有一个参数，我们也可以删除（），代码如下：
1 item=>item %2 == 0;
因此，我们得到如下所示的Lambda表达式：
item => item % 2 == 0
其中item是参数，=>是Lambda运算符，item % 2 == 0是正文表达式。
二、具有多个参数的Lambda表达式
如果需要传递多个参数，那么必须将参数括在括号内，如下所示：
1 (ints, item) => ints.Contains(item);
如果不想使用推断类型，那么可以给出每个参数的类型，如下所示：
1 (int[] ints, int item) => ints.Contains(item)
三、不带任何参数的Lambda表达式
在Lambda表达式中可以没有参数，如下所示：
1 () => Console.WriteLine("这是一个不带任何参数的Lambda表达式");
四、正文表达式中有多条语句
在前面讲过，如果正文表达式有一个语句，那么可以去掉方法体外面的大括号。如果正文表达式中有多条语句，那么必须用大括号将正文表达式括起来，如下所示：
(ints, item) =>
{
Console.WriteLine("这是包含多条语句的Lambda表达式");
return ints.Contains(item);
};
五、表达式中的局部变量
你可以在表达式的主体中声明一个变量，以便在表达式主体的任何位置使用它，如下所示：
1 ints =>
2 {
3 int item = 10;
4 return ints.Contains(item);
5 };
六、Lambda表达式中的内置泛型委托
1、Func委托
当你想从lambda表达式返回一些东西时，使用Func <> delegate。
其中T是输入参数的类型，TResult是返回类型。
示例代码如下：
1 Func<int[], bool> isContains = p => p.Equals(10);
2 int[] ints = { 5, 2, 0, 66, 4, 32, 7, 1 };
3 bool isEquals = isContains(ints);
在上面的例子中，Func委托期望第一个输入参数是int[]类型，返回类型是boolean。Lambda表达式是p => p.Equals(10)。
2、Action委托
与Func委托不同，Action委托只能有输入参数。 当不需要从lambda表达式返回任何值时，请使用Action委托类型。
示例代码如下：
1 Action<int[]> PrintItem = p =>
2 {
3 foreach (int item in p)
4 {
5 Console.WriteLine(item);
6 }
7 };
8 int[] ints = { 5, 2, 0, 66, 4, 32, 7, 1 };
9 PrintItem(ints);
七、在LINQ中使用Lambda表达式
通常情况下，Lambda表达式与LINQ查询一起使用。枚举静态类包括接受Func <TSource，bool>的IEnumerable <T>的Where扩展方法。IEnumerable <Int>集合的Where（）扩展方法需要传递Func <Student，bool>，如下所示：
现在，您可以将分配给Func委托的lambda表达式传递给方法语法中的Where（）扩展方法，如下所示：
1 Func<int, bool> isContains = p =>p.Equals (4);
2 int[] ints = { 5, 2, 0, 66, 4, 32, 7, 1 };
3 var result = ints.Where(isContains).ToList();
八、Lambda表达式要点总结
1、Lambda表达式是一种表示匿名方法的更短的方法。
2、Lambda表达式语法：parameters =>正文表达式
3、Lambda表达式可以在（）中具有零个或多个参数。
4、Lambda表达式可以在大括号{}中的正文表达式中有一条或多条语句。
5、Lambda表达式可以分配给Func，Action或Predicate委托。
6、Lambda表达式可以以类似的方式调用委托。
四 实例操作
一、什么是LINQ
LINQ是Language Integrate Query的缩写，意为语言集成查询，是微软在.Net Framework 4.5版中推出的主要特性之一。
它为开发人员提供了统一的数据查询模式，并与.Net开发语言（如C#和VB.Net）集成，很大程度上简化了数据查询的编码和调试工作，提供了数据查询的性能。
LINQ中查询表达式访问的是一个对象，而该对象可以表示为各种类型的数据源。比如SQL Server数据库，XML文档，ADO.NET数据集，以及内存中的数据集合等。
在.NET类库中，LINQ相关类库都在System.Linq命名空间中，该命名空间提供支持使用LINQ进行查询的类和接口，其中主要是以下两个接口和两个类：
IEnumerable<T>接口：它表示可以查询的数据集合，一个查询通常是逐个对集合对象中的元素进行筛选操作，返回一个新的IEnumerable<T>对象，用来保存查询结果。
IQueryable<T>接口：它继承自IEnumerable<T>接口，表示一个可以查询的表达式目录树。
Enumerable类：它通过对IEnumerable<T>提供扩展方法，实现LINQ标准查询运算。包括过滤、导航、排序、关联、求和、求最大值、求最小值等操作。
Queryable类：它通过对IQueryable<T>提供扩展方法，实现LINQ标准查询运算。包括过滤、导航、排序、关联、求和、求最大值、求最小值等操作。
根据数据源类型，可以将LINQ技术分为以下几个主要技术方向：
1.LINQ to Object:数据源为实现了接口IEnumerable<T>和IQueryable<T>的内存数据集合，这也是LINQ的基础，本文将介绍着方面的内容。
2.LINQ to ADO.NET:数据源为ADO.NET数据集，这里将数据库中的表结构映射到类结构，并通过ADO.NET从数据库中获取数据集到内存，通过LINQ进行数据查询。
3.LINQ to XML:数据源为XML文档，这里通过XElement、XAttribute等类将XML文档数据加载到内存中，通过LINQ进行数据查询。
二、LINQ查询表达式
在进行LINQ查询的编写之前，首先要了解查询表达式。查询表达式是LINQ查询的基础，也是最常用的编写LINQ查询的方法。查询表达式由查询关键字和对应的操作数组成。其中，查询关键字是常用的查询运算符。
在C# 3.0中可以直接使用的查询关键字和功能如下表：
1.用from子句指定数据源
每个LINQ查询表达式都以from子句开始，from子句包括以下两个功能。
（1）指定查询将采用的数据源
（2）定义一个本地变量，表示数据源中单个数据
单个from子句的编写格式为： from localVar in dataSource，其中，dataSource表示数据源，localVar表示单个元素。
示例代码如下：
int[] array = { 1, 2, 4, 5, 7 };
var query = from item in array
select item;
foreach (var item in query)
{
Console.WriteLine(item);
}
2.使用select子句指定目标数据源
select子句指定在执行查询是产生的结果类型，其格式为：select element，其中elment参数指定查询结果中元素的类型及初始化方式。
在进一步介绍select子句之前，先介绍一下本文示例中要用到的实体类：
public class LessonScore
{
/// <summary>
/// 课程成绩
/// </summary>
public float Score { get; set; }
/// <summary>
/// 课程名称
/// </summary>
public string Lession { get; set; }
public override string ToString()
{
return string.Format("{0}-----{1}分",Lession,Score);
}
}
public class Student
{
/// <summary>
/// 学生名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 学生性别
/// </summary>
public string XingBie { get; set; }
/// <summary>
/// 学生年龄
/// </summary>
public int Age { get; set; }
public List<LessonScore> Scores { get; set; }
public override string ToString()
{
return string.Format("{0}---{1}---{2}",Name, XingBie,Age);
}
}
select子句中要选择的目标类型不仅可以为数据源中的元素，还可以是该元素的不同操作结果，包括属性、方法和运算等。示例代码如下：
Student[] students = {
new Student() {Name="乔峰",Age=20,XingBie="男" },
new Student() {Name="欧阳修",Age=22,XingBie="男" },
new Student() {Name="王五",Age=19,XingBie="男" },
new Student() {Name="王丹",Age=20,XingBie="女" },
new Student() {Name="倾国倾城",Age=18,XingBie="女" }
};
var query1 = from student in students
select student;//整个元素作为查询结果
foreach (var item in query1)
{
Console.WriteLine(item);
}
var query2 = from student in students
select student.Name;//元素的属性作为查询结果
foreach (var item in query2)
{
Console.WriteLine(item);
}
var query3 = from student in students
select student.Name.Length;
foreach (var item in query3)
{
Console.WriteLine(item);
}
在某些特殊的场合下，往往查询结果只是临时使用一下，而查询结果的数据包括很多字段，并非一个简单的属性、方法返回值等。这时，可在select子句中使用匿名类型来解决这类问题。
示例代码如下：
//返回数据源中学生的姓名、年龄、姓名的长度
//使用匿名类型方式返回
var query4 = from student in students
select new {student.Name,student.Age,NameLen = student.Name.Length };
foreach (var item in query4)
{
Console.WriteLine(item);
}
3.使用where子句指定筛选条件
通常一个LING查询不会如前面的示例代码那么简单，通常还需要对数据源中的元素进行过滤。只有符合条件的元素，才能参与查询结果的计算。
LINQ中，where子句格式为：where expression,其中，expression是一个逻辑表达式，返回布尔值。
where子句中的条件表达式，可以用&&和||指定多个条件的逻辑运算关系。其中，&&表示逻辑并，||表示逻辑或。
示例代码：
int[] array = { 1,3,9,5,16,20,54,60,18,37};
var query1 = from item in array //查询array中所以大于15的元素
where item > 15
select item;
foreach (var item in query1)
{
Console.Write("{0}, ",item);
}
Console.WriteLine();
var query2 = from item in array //查询array中所以大于10小于40的元素
where item > 10 && item < 40
select item;
foreach (var item in query2)
{
Console.Write("{0}, ", item);
}
Console.WriteLine();
var query3 = from item in array //查询array中小于10或者大于40的元素
where item < 10 || item > 40
select item;
foreach (var item in query3)
{
Console.Write("{0}, ", item);
}
4.使用orderby子句进行排序
在一些场合，还需要对查询结果进行排序。在LINQ中，通过orderby子句对查询结果进行排序操作。
orderby子句格式为：orderby element [ascending|descending],其中element是要进行排序的字段，可以是数据源中的数据，也可以是对元素操作的结果。
[ascending|descending]是排序类型，ascending为升序，descending为降序，默认请客下为ascending。
示例代码：
int[] array = { 1, 3, 9, 5, 16, 20, 54, 60, 18, 37 };
var query1 = from item in array //升序
orderby item
select item;
foreach (var item in query1)
{
Console.Write("{0}, ", item);
}
Console.WriteLine();
var query2 = from item in array //降序
orderby item descending
select item;
foreach (var item in query2)
{
Console.Write("{0}, ", item);
}
Console.WriteLine();
在LINQ中，orderby子句可以同时指定多规排序元素，还可以为每个元素指定独立的排序类型。orderby语句后的第一个排序元素为主要排序，第二个为次要排序，以此类推。
示例代码如下：
Student[] students = {
new Student() {Name="乔峰",Age=20,XingBie="男" },
new Student() {Name="欧阳修",Age=22,XingBie="男" },
new Student() {Name="王五",Age=19,XingBie="男" },
new Student() {Name="王丹",Age=20,XingBie="女" },
new Student() {Name="倾国倾城",Age=18,XingBie="女" }
};
//主要按姓名长度从小到大，次要按年龄从大到小
var query3 = from stu in students
orderby stu.Name.Length ascending, stu.Age descending
select stu;
foreach (var item in query3)
{
Console.WriteLine(item);
}
5.使用group子句进行分组
在LINQ中，用group子句实现对查询结果的分组操作。group子句的常用格式为：group element by key。其中,element表示作为查询结果返回的元素，key表示分组条件。
group子句返回类型为IGrouping<TKey,TElement>的查询结果。
示例代码如下：
Student[] students = {
new Student() {Name="乔峰",Age=22,XingBie="男" },
new Student() {Name="欧阳修",Age=22,XingBie="男" },
new Student() {Name="王五",Age=19,XingBie="男" },
new Student() {Name="王丹",Age=19,XingBie="女" },
new Student() {Name="倾国倾城",Age=19,XingBie="女" }
};
//按学生性别分组
var query1 = from stu in students
group stu by stu.XingBie;
foreach (var grp in query1)
{
Console.WriteLine(grp.Key);
foreach (var item in grp)
{
Console.WriteLine(item);
}
}
//按多条件分组，按性别和年龄分组
var query2 = from stu in students
group stu by new { stu.XingBie, stu.Age };
foreach (var grp in query2)
{
Console.WriteLine("{0}---{1}",grp.Key.XingBie,grp.Key.Age);
foreach (var item in grp)
{
Console.WriteLine(item);
}
}
有时候需要对分组的结果进行排序、再次查询等操作。这就需要使用into关键字将group查询的结果保存到一个临时变量，并且必须使用select子句对其进行重新查询。
into关键字语法为：group element by key into grp，其中，tmpGrp表示一个本地变量，用来临时保存group产生的结果，提供后面的LINQ子句使用。
示例代码如下：
Student[] students = {
new Student() {Name="乔峰",Age=22,XingBie="男" },
new Student() {Name="欧阳修",Age=22,XingBie="男" },
new Student() {Name="王五",Age=19,XingBie="男" },
new Student() {Name="王丹",Age=19,XingBie="女" },
new Student() {Name="倾国倾城",Age=19,XingBie="女" }
};
var query3 = from stu in students
group stu by stu.Age into grp
orderby grp.Key descending
select grp;
foreach (var grp in query3)
{
Console.WriteLine("{0}岁的学生：", grp.Key);
foreach (var item in grp)
{
Console.WriteLine(item);
}
}
