走进 LINQ 的世界

  在此之前曾发表了三篇有关 LINQ 的随笔:

    进阶:《LINQ
标准查询操作概述》(强烈推荐)

    技巧:《Linq To Objects –
如何操作字符串》 和
《Linq To Objects –
如何操作文件目录》

  现在,自己打算再整理一篇有关 LINQ 入门的随笔,也是活泼的哦。

 

目录

  • LINQ 简介
  • 介绍 LINQ
    查询
  • LINQ
    基本查询操作
  • 以 LINQ
    进行数据易
  • LINQ
    查询操作的路涉及
  • LINQ
    中的查询语法和方法语法

 

LINQ 简介

  语言集成查询 (LINQ) 是 Visual Studio 2008 和 .NET Framework 3.5
版中引入的一样起创新力量。

  传统上,针对数据的查询都是坐略的字符串表示,而尚未编译时类型检查或
IntelliSense
支持。此外,您还得对以下各种数据源学习一栽不同的查询语言:SQL
数据库、XML 文档、各种 Web 服务等等。 通过LINQ,
您可使用语言关键字与习的演算符针对强类型化对象集合编写查询。

  

  于 Visual Studio 中,可以吧以下数据源编写 LINQ 查询:SQL Server
数据库、XML 文档、ADO.NET
数据集,以及支持 IEnumerable 或泛型 IEnumerable<T> 接口的任性对象集合。

  使用要求:项目 ≥ .NET Framework 3.5 。

 

一、介绍 LINQ 查询

  查询是一模一样种于数据源检索数据的表达式。随着年华之推移,人们早就为各种数据源开发了不同之言语;例如,用于关系数据库的
SQL 和用来 XML 的
XQuery。因此,开发人员不得不对他们不能不支持之每种数据源或数格式而学新的查询语言。LINQ
通过提供平等种跨数据源和数据格式使用数据的一模一样模型,简化了立即无异气象。在
LINQ 查询中,始终会因此到对象。可以应用同样之编码模式来查询以及转移 XML
文档、SQL 数据库、ADO.NET 数据集、.NET 集合中之数与针对性其发生 LINQ
提供程序可用之另外其它格式的数额。  

 

  1.1 查询操作的老三独片

  操作三管辖曲:①得到多少源 ②创建查询 ③履行查询

 1 internal class Program
 2 {
 3         private static void Main(string[] args)
 4         {
 5             //1.获取数据源
 6             var nums = new int[7] { 0, 1, 2, 3, 4, 5, 6 };
 7 
 8             //2.创建查询
 9             var numQuery =
10                 from num in nums
11                 where (num % 2) == 0
12                 select num;
13 
14             //3.执行查询
15             foreach (var num in numQuery)
16             {
17                 Console.WriteLine("{0}", num);
18             }
19         }
20 }

View Code

 

   下图展示了整机的查询操作。在 LINQ
中,查询的尽及查询自己截然不同;换句话说,查询自己指的是仅开创查询变量,不搜任何数据。

  

  1.2 数据源

  以直达一个演示中,由于数据源是屡组,因此她隐式支持泛型 IEnumerable<T> 接口。支持 IEnumerable<T> 或派生接口(如泛型 IQueryable<T>)的门类称为可查询类型。  

  可查询类型不需开展改动要独特处理便得就此作 LINQ
数据源。如果来数据还尚无作为可查询类型出现在内存中,则 LINQ
提供次要以此方法表示来数据。例如,LINQ to XML 将 XML
文档加载到但是查询的 XElement 类型中:

  //从 XML 中创建数据源
  //using System.Xml.Linq;
  var contacts = XElement.Load(@"c:\xxx.xml");

  

  于 LINQ to SQL 中,首先要创建对象关系映射。
针对这些目标编排查询,然后由 LINQ to SQL 在运作时处理同数据库的通信。

1     var  db = new Northwnd(@"c:\northwnd.mdf");
2     
3     //查询在伦敦的客户
4     var custQuery =
5         from cust in db.Customers
6         where cust.City == "London"
7         select cust;

Customers 代表数据库中之特定表

 

  1.3 查询

  查询指定要起数据源中检索的音信。
查询还好指定在回来这些信之前如何对该展开排序、分组和结构化。
查询存储在询问变量中,并就此查询表达式进行初始化。

  之前的示范中之询问是自从整数数组中归所有的偶数。
该查询表达式包含三单子句:fromwhere 和 select。(如果你熟悉
SQL,您会注意到这些子句的依次及 SQL
中之次第相反。)from 子词指定数据源,where 子句指定应用筛选器,select 子句指定返回的因素的种类。
目前得留意的凡,在 LINQ 中,查询变量本身不履另外操作而不返外数据。
它只是存储在其后有时刻执行查询时为浮动结果而必要的信。

 

  1.4 查询执行

  1.延缓执行

    如前所述,查询变量本身只是存储查询命令。  实际的询问执行会延迟到在 foreach 语句子被循环访问查询变量时出。
此概念叫“延迟执行”。

  2.强制立即执行

    对相同多重源元素执行聚合函数的查询必须首先循环访问这些要素。CountMaxAverage 和 First 就属此类查询。由于查询自己必须使用 foreach 以便回到结果,因此这些查询在尽时不行使显式 foreach 语句子。另外还要注意,这些品种的询问返回单个值,而未是 IEnumerable 集合。 

1     var numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };
2 
3     var evenNumQuery =
4         from num in numbers
5         where (num % 2) == 0
6         select num;
7 
8     var evenNumCount = evenNumQuery.Count();

View Code

 

  若一旦强制立即执行任意查询并缓存其结果,可以调用 ToList<TSource> 或 ToArray<TSource> 方法。

1     var numQuery2 =
2            (from num in numbers
3             where (num % 2) == 0
4             select num).ToList();
5 
6     var numQuery3 =
7           (from num in numbers
8            where (num % 2) == 0
9             select num).ToArray();

View Code

 

  此外,还可由此当紧跟查询表达式之后的位置放置一个 foreach 循环来强制执行查询。但是,通过调用 ToList 或 ToArray,也可以有数据缓存在单个集合对象被。 

 

仲、基本 LINQ 查询操作

  2.1 获取数据源:from

  在 LINQ
查询中,第一步是点名数据源。像以大部分编程语言中同样,必须事先声明变量,才会使它。在
LINQ 查询中,最先祭 from 子词的目的是引入数据源和限制变量。

1     //queryAllCustomers 是 IEnumerable<Cutsomer> 类型
2     //数据源 (customers) 和范围变量 (cust)
3     var queryAllCustomers = from cust in customers
4                                            select cust;

View Code

  范围变量类似于 foreach 循环中的迭代变量,但于询问表达式中,实际上不发出迭代。执行查询时,范围变量将因此拿 customers 中之每个后续元素的援。因为编译器可以推断 cust 的品种,所以您不用显式指定此类型。

 

  2.2 筛选:where

  也许不过常用之查询操作是采取布尔表达式形式之筛选器。此筛选器使查询才回去那些表达式结果也
true 的因素。使用 where 子句子生成结果。实际上,筛选器指定从源序列中祛哪些因素。

1     var queryLondonCustomers = from cust in customers
2                                   where cust.City = "London"
3                                     select cust;

独自回地址在伦敦的 customers。

  您得用深谙的 C#
逻辑 AND(&&)和 OR(||) 运算符来根据需要以 where 子句被动用任意数量之筛选表达式。 

where cust.City = "London" && cust.Name = "Devon"

设若使才回位于“伦敦”和人名也“Devon”的客户

where cust.City = "London" || cust.Name = "Paris"

假设使回到位于伦敦要巴黎的客户

 

  2.3 排序:orderby

  通常可以充分便利地以回来的数开展排序。orderby 子句以使返回的队中之要素以让排序的型的默认比较器进行排序。

1     var queryLondonCustomers = from cust in customers
2                                where cust.City = "London"
3                                orderby cust.Name descending 
4                                select cust;

以 Name 属性对结果进行排序

  因为 Name 是一个字符串,所以默认比较器执行打 A 到 Z
的假名排序。若使依照倒顺序(从 Z 到 A)对结果进行排序,请以 orderby…descending 子句。

 

  2.4 分组:group

  使用 group 子词,您可以以指定的键分组结果。

 1     var queryLondonCustomers = from cust in customers
 2                     group cust by cust.City;
 3 
 4     foreach (var queryLondonCustomer in queryLondonCustomers)
 5     {
 6        Console.WriteLine(queryLondonCustomer.Key);
 7        foreach (var cust in queryLondonCustomer)
 8        {
 9           Console.WriteLine(cust.Name);
10        }
11     }

乃可指定结果应以 City
分组,以便在伦敦抑或巴黎底保有客户在各自组中。

  于本例中,cust.City 是键。

  在使用 group 子句子结束查询时,结果用列表的列表形式。列表中的每个元素是一个具 Key 成员及基于该键分组的素列表的靶子。在循环访问生成组序列的询问时,您要用嵌套的 foreach 循环。外部循环用于循环访问每个组,内部循环用于循环访问每个组的分子。
 

  如果您得引用组操作的结果,可以用 into 关键字来创造而更询问的标识符。

1     //custQuery 是 IEnumable<IGrouping<string, Customer>> 类型
2     var custQuery = from cust in customers
3                     group cust by cust.City
4                     into custGroup
5                     where custGroup.Count() > 2
6                     orderby custGroup.Key
7                     select custGroup;

此的询问才回那些带有两单以上之客户之组。

 

  2.5 联接:join

  联接运算创建数量源中没有显式建模的行里的涉及。例如,您得推行属来搜寻在同地方的有着客户和经销商。在
LINQ 中,join 子句始终对准对象集合而非直接对数据库表运行。  

1     var innerJoinQuery = from cust in customers
2                        join dist in distributors on cust.City equals dist.City
3                        select new {CustomerName = cust.Name, DistributorName = dist.Name};

诸如,您得履属来查找在同一地方的富有客户和经销商。

  在 LINQ 中,join 子句始终本着对象集合而休直接对数据库表运行。
 

  在 LINQ 中,您不要像于 SQL 中那样频繁使用 join,因为 LINQ
中的外键在靶模型中象征为带有项集合的习性。

    from order in Customer.Orders...

如,Customer 对象涵盖 Order
对象的聚集。不必执行属,只待使用点表示拟访问订单。

  

  2.6 选择(投影):select

  select 子句子生成查询结果连点名每个返回的素的“形状”或项目。

  例如,您得指定结果包含的凡全 Customer 对象、仅一个成员、成员的子集,还是有因计算还是新对象创建的毕两样之结果类型。当 select 子句生成除源元素副本以外的情节时,该操作称为“投影”。

 

其三、使用 LINQ 进行数据易

  语言集成查询 (LINQ)
不仅可用以检索数据,而且要一个功能强大的数码易工具。通过运用 LINQ
查询,您可用自序列用作输入,并以多种道修改它因为创建新的出口序列。您得透过排序和分组来窜该队,而毋庸修改元素本身。但是,LINQ
查询的最为劲的力量是力所能及创造新类型。这无异效果以 select 子句被实现。 例如,可以推行下列职责:  

  

  3.1 将大半只输入联接到一个输出序列

 1     class Student
 2     {
 3         public string Name { get; set; }
 4 
 5         public int Age { get; set; }
 6 
 7         public string City { get; set; }
 8 
 9         public List<int> Scores { get; set; }
10     }
11 
12     class Teacher
13     {
14         public int Id { get; set; }
15 
16         public string Name { get; set; }
17 
18         public int Age { get; set; }
19 
20         public string City { get; set; }
21 
22     }

学员与导师两单近乎

 1     internal class Program
 2     {
 3         private static void Main(string[] args)
 4         {
 5             //创建第一个数据源
 6             var students = new List<Student>()
 7             {
 8                 new Student()
 9                 {
10                     Age = 23,
11                     City = "广州",
12                     Name = "小C",
13                     Scores = new List<int>(){85,88,83,97}
14                 },
15                 new Student()
16                 {
17                     Age = 18,
18                     City = "广西",
19                     Name = "小明",
20                     Scores = new List<int>(){86,78,85,90}
21                 },
22                 new Student()
23                 {
24                     Age = 33,
25                     City = "梦里",
26                     Name = "小叁",
27                     Scores = new List<int>(){86,68,73,97}
28                 }
29             };
30 
31             //创建第二个数据源
32             var teachers = new List<Teacher>()
33             {
34                 new Teacher()
35                 {
36                     Age = 35,
37                     City = "梦里",
38                     Name = "啵哆"
39                 },
40                 new Teacher()
41                 {
42                     Age = 28,
43                     City = "云南",
44                     Name = "小红"
45                 },
46                 new Teacher()
47                 {
48                     Age = 38,
49                     City = "河南",
50                     Name = "丽丽"
51                 }
52             };
53 
54             //创建查询
55             var peopleInDreams = (from student in students
56                             where student.City == "梦里"
57                             select student.Name)
58                             .Concat(from teacher in teachers
59                                     where teacher.City == "梦里"
60                                     select teacher.Name);
61 
62             //执行查询
63             foreach (var person in peopleInDreams)
64             {
65                 Console.WriteLine(person);
66             }
67 
68             Console.Read();
69         }
70     }

决定高出口代码。   

 

  3.2 选择各个源元素的子集

  1. 若一旦一味选取源元素的一个成员,请用点运算。

1     var query = from cust in Customers
2                     select cust.City;

  

  2. 使要创建包含源元素的差不多独特性之素,可以采取有命名对象或匿名类型的目标初始值设定项。

1     var query = from cust in Customer
2                    select new {Name = cust.Name, City = cust.City};

 

  3.3 将内存中的目标转换为 XML

 1             //创建数据源
 2             var students = new List<Student>()
 3             {
 4                 new Student()
 5                 {
 6                     Age = 18,
 7                     Name = "小A",
 8                     Scores = new List<int>() {88,85,74,66 }
 9                 },
10                 new Student()
11                 {
12                     Age = 35,
13                     Name = "小B",
14                     Scores = new List<int>() {88,85,74,66 }
15                 },
16                 new Student()
17                 {
18                     Age = 28,
19                     Name = "小啥",
20                     Scores = new List<int>() {88,85,74,66 }
21                 }
22             };
23 
24             //创建查询
25             var studentsToXml = new XElement("Root",
26                 from student in students
27                 let x = $"{student.Scores[0]},{student.Scores[1]},{student.Scores[2]},{student.Scores[3]}"
28                 select new XElement("student",
29                 new XElement("Name", student.Name),
30                 new XElement("Age", student.Age),
31                 new XElement("Scores", x))
32             );
33 
34             //执行查询
35             Console.WriteLine(studentsToXml);

View Code

 

  3.4 对源元素执行操作

  输出序列可能未带有源序列的别因素或因素属性。输出可能是通过以源元素用作输入参数计算起之价的排。

 1             //数据源
 2             double[] radii = {1, 2, 3};
 3 
 4             //创建查询
 5             var query = from radius in radii
 6                 select $"{radius * radius * 3.14}";
 7 
 8             //执行查询
 9             foreach (var i in query)
10             {
11                 Console.WriteLine(i);
12             }

View Code

   【备注】$”{radius
* radius * 3.14}” 相当于 string.Format(“{0}”,radius * radius *
3.14),这里运用的凡 C# 6.0 的语法。

 

季、LINQ 查询操作的类型涉及

  LINQ
查询操作以数据源、查询自己和查询执行着凡强类型的。查询中变量的种必须和数据源中元素的类和 foreach 语词中迭代变量的档次兼容。强类型可以保在编译时捕获类型错误,以便就改正。

 

  4.1 不转换源数据的查询

  下图演示不对数据实行转换的 LINQ to Objects
查询操作。源包含一个字符串序列,查询输出为是一个字符串序列。 

  ①数据源的型参数决定限制变量的档次。

  ②选的靶子的品类决定查询变量的类型。此处的 name 为一个字符串。因此,查询变量是一个 IEnumerable<字符串>。
 

  ③在 foreach 语词被循环访问查询变量。因为查询变量是一个字符串序列,所以迭代变量也是一个字符串。
 

 

  4.2 转换源数据的查询

  下图演示对数据实施简单转换的 LINQ to
SQL 查询操作。查询将一个 Customer 对象序列用作输入,并只选结果丁的 Name 属性。因为 Name 是一个字符串,所以查询生成一个字符串序列作为出口。  

  ①数据源的型参数决定限制变量的种类。

  ②select 语句返回 Name 属性,而非完全的 Customer 对象。因为 Name 是一个字符串,所以 custNameQuery 的项目参数是 string,而非Customer。
 

  ③因为 custNameQuery 是一个字符串序列,所以 foreach 循环的迭代变量也必是 string

 

  下图演示另一样种易。select 语句返回就捕获原始 Customer 对象的蝇头只分子的匿名类型。

  ①数据源的门类参数始终为查询中之克变量的品种。

  ②因为 select 语句生成匿名类型,所以必须使 var 隐式类型化查询变量。

  ③缘查询变量的路是隐式的,所以 foreach 循环中之迭代变量也必是隐式的。

 

  4.3 让编译器推断类型信息

  您也可动用主要字 var,可用以查询操作中之任何有变量。但是,编译器为查询操作着之逐条变量提供强类型。  

 

五、LINQ 中之查询语法和方式语法

  我们编辑的 LINQ 查询语法,在编译代码时,CLR
会将查询语法转换为法语法。这些措施调用标准查询运算符的名类似 WhereSelectGroupByJoinMax和 Average,我们为是可直接使用这些点子语法的。
 

  查询语法和道语法语义相同,但是,许多口发现查询语法更简短、更易阅读。某些查询必须代表为方式调用。例如,必须以方式调用表示找元素的数与指定的尺码的查询。还非得采取方法需要摸索元素的最好老价值当来源序列的查询。System.Linq 命名空间中的正规查询运算符的参阅文档通常采用办法语法。

 

  5.1 标准查询运算符扩展方法

 1         static void Main(string[] args)
 2         {
 3             var nums = new int[4] { 1, 2, 3, 4 };
 4             
 5             //创建查询表达式
 6             var qureyNums = from n in nums
 7                             where n % 2 == 0
 8                             orderby n descending
 9                             select n;
10 
11             Console.WriteLine("qureyNums:");
12             foreach (var n in qureyNums)
13             {
14                 Console.WriteLine(n);
15             }
16     
17             //使用方法进行查询
18             var queryNums2 = nums.Where(n => n % 2 == 0).OrderByDescending(n => n);
19 
20             Console.WriteLine("qureyNums2:");
21             foreach (var n in queryNums2)
22             {
23                 Console.WriteLine(n);
24             }
25 
26             Console.Read();
27         }

下面的言传身教演示简单的询问表达式和编排为根据方法的询问的语义上同一的查询。

  两单示范的出口是均等之。您得看看个别栽形式之询问变量的品类是同样之:IEnumerable<T>。
 

  若使询问因方法的询问,让我们越地分析其。注意,在表达式的下手,where 子句现在表示也对 numbers 对象的实例方法,在公再也调用该对象时那个种类也 IEnumerable<int>。如果你熟悉泛型 IEnumerable<T> 接口,那么您就会见询问,它不负有 Where 方法。但是,如果您于
Visual Studio IDE 中调用 IntelliSense
完成列表,那么您不只拿见到 Where 方法,而且还见面看出不少其他办法,如 SelectSelectManyJoin 和Orderby。下面是具专业查询运算符。 

  尽管看起 IEnumerable<T> 似乎已经让重复定义为囊括这些附加措施,但实则并非如此。这些规范查询运算符都是用作“扩展方法”实现之。

 

  5.2 Lambda 表达式

  于头里的言传身教中,通知该规范发挥式 (num % 2 == 0) 是作为内联参数。Where 方法:Where(num
=> num % 2 == 0) 此内联表达式称为 lambda
表达式。将代码编写为匿名方式要泛型委托或表达式树是平等种植便民的主意,否则编写起来便设累得多。=> 是
lambda 运算符,可读吧“goes
to”。运算符左侧的 num 是输入变量,与查询表达式中之 num 相对应。编译器可想 num 的项目,因为它们了解 numbers 是泛型 IEnumerable<T> 类型。lambda
表达式与查询语法中之表达式或任何其他 C#
表达式或报句被的表达式相同;它好概括方法调用和外复杂逻辑。“返回值”就是表达式结果。
 

 

  5.3 查询的组合性

  以点的代码示例中,请留意 OrderBy 方法是通过以对 Where 的调用中利用点运算符来调用的。Where 生成筛选序列,然后 Orderby 通过对该队排序来对它们进行操作。因为查询会返回 IEnumerable,所以若可是透过将方调整用链接以一齐,在道语法中拿这些查询组合起来。这就是是于公通过运用查询语法编写查询时编译器在后台所执之操作。并且由查询变量不存储查询的结果,因此而可随时修改它要以她因此作新查询的功底,即使以执行其后。

 

传送门

  入门:《走进 LINQ
的世界》

  进阶:《LINQ
标准查询操作概述》(强烈推荐)

  技巧:《Linq To Objects –
如何操作字符串》 和
《Linq To Objects –
如何操作文件目录》

 

 


本文首联:http://www.cnblogs.com/liqingwen/p/5832322.html

【参考】https://msdn.microsoft.com/zh-cn/library/bb397897(v=vs.100).aspx

【来源】本文引用部分微软官方文档的图

 

 

  

相关文章

网站地图xml地图