开始使用
分类:计算机编程

走进 LINQ 的世界

[C#] 开始运用 LINQ,

 

  早前曾刊登过三篇关于 LINQ 的小说:

    进阶:《LINQ 规范查询操作概述》(生硬推荐)

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

  以往,自个儿筹算再收拾生龙活虎篇关于 LINQ 入门的小说,也是活龙活现的哦。

 

始于选取 LINQ 

  以前曾刊登过三篇关于 LINQ 的随笔:

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

    技能:《Linq To Objects - 如何操作字符串》 和 《Linq To Objects

  • 怎么着操作文件目录》

  以往,本人筹划再整理意气风发篇关于 LINQ 入门的小说。为了幸免篇幅过长,最后仍旧选取将代码折叠起来。

  • LINQ

目录

  • LINQ 简介
  • 介绍 LINQ 查询
  • LINQ 基本查询操作
  • 利用 LINQ 举行数量转变
  • LINQ 查询操作的品类涉及
  • LINQ 中的查询语法和办俄语法

 

  语言集成查询 (LINQ) 是 Visual Studio 二〇〇八 和 .NET Framework 3.5 版中引进的大器晚成项改善成效。

  古板上,针对数据的查询都以以简单的字符串表示,而还未编写翻译时类型检查或 速龙liSense 支持。此外,您还必需针对以下各样数据源学习风姿罗曼蒂克种区别的询问语言:SQL 数据库、XML 文书档案、种种 Web 服务等等。 通过LINQ, 您还行语言关键字和熟习的运算符针对强类型化对象集结编写查询。

图片 1

  

  在 Visual Studio 中,可认为以下数据源编写 LINQ 查询:SQL Server 数据库、XML 文书档案、ADO.NET 数据集,以致支持 IEnumerable 或泛型 IEnumerable<T> 接口的轻巧对象集结。   使用须要:项目 ≥ .NET Framework 3.5 。  

     语言集成查询 (LINQ) 是 Visual Studio 二〇一〇 中引进的生机勃勃组效率,它在对象领域和数据领域之间架起了生龙活虎座大桥。可为 C# 和 Visual Basic 语言语法提供强有力的询问功效。 LINQ 引入了业内、易学的数量查询和更新形式,该技巧能够增加为大致辅助任何类型的数码存款和储蓄。Visual Studio 富含 LINQ 提供程序的程序集,依靠那个程序集,就可以将 LINQ 用于 .NET Framework 集结、SQL Server 数据库、ADO.NET 数据集和 XML 文书档案。

LINQ 简介

  语言集成查询 (LINQ) 是 Visual Studio 二零零六 和 .NET Framework 3.5 版中引进的风流罗曼蒂克项创新作用。

  传统上,针对数据的查询都以以简洁明了的字符串表示,而并未有编写翻译时类型检查或 速龙liSense 帮衬。别的,您还必需针对以下各样数据源学习风流浪漫种不一样的询问语言:SQL 数据库、XML 文书档案、各个 Web 服务等等。 通过LINQ, 您能够行使语言关键字和熟稔的运算符针对强类型化对象会集编写查询。

图片 2

  

  在 Visual Studio 中,可以为以下数据源编写 LINQ 查询:SQL Server 数据库、XML 文书档案、ADO.NET 数据集,甚至扶助 IEnumerable 或泛型 IEnumerable<T> 接口的妄动对象集合。

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

 

目录

  • 介绍 LINQ 查询
  • LINQ 基本查询操作
  • 动用 LINQ 进行数量转变
  • LINQ 查询操作的项目涉及
  • LINQ 中的查询语法和办法文法

 

  • LINQ应用场景
    • LINQ to Object:针对数组和集纳
    • LINQ to XML:针对XML文档
    • LINQ to DataSet:针对ADO的DataSet对象
    • LINQ to Entites:针对EF
    • Parallel LINQ:并行管理LINQ查询重临的数量
  • LINQ 查询

一、介绍 LINQ 查询

  查询是风度翩翩种从数据源检索数据的表明式。随着年华的延期,大家已经为各类数据源开辟了区别的言语;例如,用于关全面据库的 SQL 和用于 XML 的 XQuery。由此,开垦人士必须要针对他们一定要扶助的每个数据源或数量格式而上学新的查询语言。LINQ 通过提供大器晚成种跨数据源和数量格式使用数据的后生可畏律模型,简化了那大器晚成情形。在 LINQ 查询中,始终会用到指标。能够利用相似的编码方式来查询和转换 XML 文档、SQL 数据库、ADO.NET 数据集、.NET 集结中的数据以致对其有 LINQ 提供程序可用的别样此外格式的数据。  

 

一、介绍 LINQ 查询

  查询是后生可畏种从数据源检索数据的表明式。随着时间的延迟,大家早已为种种数据源开采了不相同的语言;举个例子,用于关周到据库的 SQL 和用来 XML 的 XQuery。由此,开垦人士必须要针对他们必须帮助的每一种数据源或数量格式而读书新的询问语言。LINQ 通过提供后生可畏种跨数据源和多少格式使用数据的同一模型,简化了这一动静。在 LINQ 查询中,始终会用到对象。能够使用相仿的编码形式来询问和转移 XML 文书档案、SQL 数据库、ADO.NET 数据集、.NET 会集中的数据以致对其有 LINQ 提供程序可用的别的别的格式的数量。  

     查询是生机勃勃种从数据源检索数据的表明式。 查询普通用极其的查询语言来表示。 随着时光的延迟,大家早就为各类数据源开垦了分化的语言;例如,用于关周全据库的 SQL 和用来 XML 的 XQuery。 由此,开辟人士必须要针对他们必得协理的每一个数据源或数额格式而读书新的询问语言。 LINQ 通过提供生龙活虎种跨各类数据源和数码格式使用数据的同样模型,简化了这大器晚成情景。 在 LINQ 查询中,始终会用到指标。 能够应用同豆蔻梢头的骨干编码形式来查询和改变XML 文书档案、SQL 数据库、ADO.NET 数据集、.NET 会集中的数据以致对其有 LINQ 提供程序可用的其他别的格式的多少。

  1.1 查询操作的多少个部分

  操作三部曲:①取多少源 ②创造查询 ③举办查询

图片 3图片 4

 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

图片 5

 

   下图突显了总体的询问操作。在 LINQ 中,查询的推行与查询本身天壤之别;换句话说,查询本人指的是只创建查询变量,不检索任何数据。

图片 6

  

  1.1 查询操作的七个部分

  操作三部曲:①取多少源 ②创办查询 ③实践查询

图片 7 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

图片 8

 

   下图展现了全部的查询操作。在 LINQ 中,查询的实践与查询本身泾渭分明;换句话说,查询本身指的是只开创查询变量,不检索任何数据。

图片 9

  

图片 10

  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 在运行时管理与数据库的通讯。

图片 11图片 12

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.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 在运转时管理与数据库的通讯。

图片 131 var db = new Northwnd(@"c:northwnd.mdf"); 2 3 //查询在London的客户 4 var custQuery = 5 from cust in db.Customers 6 where cust.City == "伦敦" 7 select cust; Customers 表示数据库中的特定表

 

 

  1.3 查询

  查询钦赐要从数量源中检索的新闻。 查询还是能内定在回去这么些音讯在此以前怎样对其展开排序、分组和结构化。 查询存款和储蓄在查询变量中,并用查询表明式进行开端化。

  此前的示范中的查询是从整数数组中回到全体的偶数。 该查询表明式包罗八个子句:fromwhere 和 select。(若是您熟识SQL,您会小心到那些子句的各种与 SQL 中的顺序相反。)from 子句钦定数据源,where 子句钦点应用筛选器,select 子句钦赐重回的要素的项目。 目前需求注意的是,在 LINQ 中,查询变量自己不推行其它操作并且不回来任何数据。 它只是存款和储蓄在其后某些时刻实践查询时为扭转结果而需要的音讯。

 

  1.3 查询

  查询内定要从数据源中检索的信息。 查询还是能钦赐在回去那么些新闻从前怎么着对其张开排序、分组和结构化。 查询存款和储蓄在查询变量中,并用查询表达式实行初叶化。

  以前的示范中的查询是从整数数组中回到全数的偶数。 该查询表明式包括八个子句:fromwhere 和 select。(借使您熟谙SQL,您会注意到这么些子句的各样与 SQL 中的顺序相反。)from 子句钦赐数据源,where 子句钦定应用筛选器,select 子句内定重临的因素的体系。 近年来急需注意的是,在 LINQ 中,查询变量本人不执行此外操作况兼不回来任何数据。 它只是存款和储蓄在随后某些时刻施行查询时为变化结果而必要的音讯。  

    • 收获数据源

  1.4 查询实施

  1.4 查询实行

     LINQ语句是在 foreach 语句中举行查询,而 foreach 要求采取 IEnumerable 或 IEnumerable<T>。帮助 IEnumerable<T> 或派生接口(如泛型 IQueryable<T>)的连串称为“可查询类型”。

  1.推迟实行

    如前所述,查询变量自身只是存款和储蓄查询命令。  实际的查询推行会延迟到在 foreach 语句中循环访谈查询变量时发出。 此概念称为“延迟奉行”。

  1.延缓试行

    如前所述,查询变量自个儿只是存款和储蓄查询命令。  实际的查询执行会延迟到在 foreach 语句中循环访谈查询变量时爆发。 此概念称为“延迟施行”。

Northwnd db = new Northwnd(@"c:northwnd.mdf");

  2.强制立时施行

    对豆蔻年华多级源成分推行聚合函数的查询必得首先循环访谈那个要素。CountMaxAverage 和 First 就属于此类查询。由于查询本身必得利用 foreach 以便回到结果,由此那几个查询在实施时不利用显式 foreach 语句。别的还要小心,那一个类别的查询重回单个值,并不是 IEnumerable 集合。 

图片 14图片 15

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

图片 16

 

  若要强制马上实践任性查询并缓存其结果,能够调用 ToList<TSource> 或 ToArray<TSource> 方法。

图片 17图片 18

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,也得以将有所数据缓存在单个集合对象中。 

 

  2.勒迫立刻实施

    对风姿罗曼蒂克层层源成分实施聚合函数的询问必需首先循环访谈这几个成分。CountMaxAverage 和 First 就属于此类查询。由于查询本身必须采取 foreach 以便回到结果,因而那一个查询在推行时不选拔显式 foreach 语句。此外还要注意,这几个项指标询问再次来到单个值,并不是 IEnumerable 集合。 

图片 191 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

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 查询操作

二、基本 LINQ 查询操作

     查询钦赐要从数量源中检索的音信。查询还是能够钦赐在再次回到这个音讯在此以前如何对其进展排序、分组和结构化。查询存款和储蓄在查询变量中,并用查询表达式举行最初化。

  2.1 获取数据源:from

  在 LINQ 查询中,第一步是钦定数据源。像在大比较多编制程序语言中千篇风流倜傥律,必需先证明变量,技术使用它。在 LINQ 查询中,最初使用 from 子句的目标是引进数据源和约束变量。

图片 20图片 21

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

View Code

  范围变量相同于 foreach 循环中的迭代变量,但在查询表明式中,实际上不发出迭代。实行查询时,范围变量将用作对 customers 中的每一种后续成分的援用。因为编写翻译器能够测算 cust 的档期的顺序,所以您不要显式钦赐此类型。

 

  2.1 获取数据源:from

  在 LINQ 查询中,第一步是点名数据源。像在半数以上编制程序语言中相像,必需先注解变量,才具利用它。在 LINQ 查询中,最初使用 from 子句的指标是引进数据源和范围变量。

图片 221 //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 子句生成结果。实际上,筛选器内定从源种类中革除哪些因素。

图片 23图片 24

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

只回去地址位于London的 customers。

  您能够采取深谙的 C# 逻辑 AND(&&)和 OR(||) 运算符来根据须要在 where 子句中接受任性数量的筛选表明式。 

图片 25图片 26

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

若要只回去位于“London”和人名叫“Devon”的客户

图片 27图片 28

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

若要再次来到位于London或法国首都的顾客

 

  2.2 筛选:where

  可能最常用的询问操作是行使布尔表达式方式的筛选器。此筛选器使查询只回去那个表达式结果为 true 的要素。使用 where 子句生成结果。实际上,挑选器钦命从源体系中消逝哪些要素。

图片 291 var queryLondonCustomers = from cust in customers 2        where cust.City = "London" 3       select cust; 只回去地址位于London的 customers。

  您能够选取深谙的 C# 逻辑 AND(&&)和 OR(||) 运算符来遵照须求在 where 子句中接纳猖獗数量的筛选表明式。 

图片 30where cust.City = "London" && cust.Name = "Devon" 若要只回去位于“London”和姓名叫“Devon”的客户 图片 31where cust.City = "London" || cust.Name = "Paris" 若要回去位于London或巴黎的客商

 

     查询变量本人只是存款和储蓄查询命令。实际的询问执行会延迟到在 foreach 语句中循环访谈查询变量时发出。此概念称为“延迟试行”

  2.3 排序:orderby

  经常能够很有利地将赶回的数据实行排序。orderby 子句将使再次回到的行列中的成分遵照被排序的类别的暗许相比器举行排序。

图片 32图片 33

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.3 排序:orderby

  常常能够很有益于地将回到的数码开展排序。orderby 子句将使重返的连串中的成分遵照被排序的类其他默许相比较器举行排序。

图片 341 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 子句。

 

foreach (int num in numQuery)
{
    Console.Write("{0,1} ", num);
}

  2.4 分组:group

  使用 group 子句,您可以按钦点的键分组结果。

图片 35图片 36

 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 分组,以便位于London或法国首都的有着客商位于各自己建设构造中。

  在本例中,cust.City 是键。

  在使用 group 子句结束查询时,结果使用列表的列表格局。列表中的每种成分是贰个具备 Key 成员及依照该键分组的因素列表的指标。在循环访问生成组类别的询问时,您必需接受嵌套的 foreach 循环。外界循环用于循环访谈种种组,内部循环用于循环访谈每一种组的分子。  

  若是您必得引用组操作的结果,能够使用 into 关键字来创立可进一步询问的标志符。

图片 37图片 38

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.4 分组:group

  使用 group 子句,您能够按钦定的键分组结果。

图片 39 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 分组,以便位于London或时尚之都的兼具客商位于各自己建立中。

  在本例中,cust.City 是键。

  在使用 group 子句甘休查询时,结果运用列表的列表格局。列表中的每一种成分是四个装有 Key 成员及基于该键分组的因素列表的对象。在循环访谈生成组体系的查询时,您必需使用嵌套的 foreach 循环。外界循环用于循环访谈每一种组,内部循环用于循环访谈各种组的成员。  

  假若你必得引用组操作的结果,能够采用 into 关键字来创制可进一步查询的标志符。

图片 401 //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 子句始终对准对象群集而非间接指向数据库表运维。  

图片 41图片 42

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 中的外键在对象模型中代表为含有项集结的质量。

图片 43图片 44

    from order in Customer.Orders...

比如,Customer 对象饱含 Order 对象的集合。不必试行联接,只需使用点表示法访谈订单。

  

  2.5 联接:join

  联接运算成立数量源中未有显式建立模型的队列之间的涉及。比方,您能够进行联接来搜求位于同意气风发地方的有着顾客和中间商。在 LINQ 中,join 子句始终本着对象集合而非直接针对数据库表运维。  

图片 451 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 中的外键在目的模型中象征为蕴含项集合的脾气。

图片 46 from order in Customer.Orders... 举例,Customer 对象饱含 Order 对象的聚合。不必推行联接,只需使用点表示法访问订单。

  

     对一各式各样源元素推行聚合函数的询问必需首先循环访问这么些要素。 Count、马克斯、Average 和 First 就属于此类查询。由于查询本身必得使用 foreach 以便回到结果,因而那些查询在实行时不采用显式 foreach 语句。此外还要小心,那么些品种的查询再次回到单个值,实际不是 IEnumerable 集合。

  2.6 选择(投影):select

  select 子句生成查询结果并钦命各种重临的因素的“形状”或项目。

  比方,您能够钦点结果满含的是整套 Customer 对象、仅八个分子、成员的子集,照旧有个别基于总计或新对象创建的通通两样的结果类型。当 select 子句生成除源成分副本以外的开始和结果时,该操作称为“投影”。

 

  2.6 选择(投影):select

  select 子句生成查询结果并钦赐每一个再次来到的因素的“形状”或项目。

  举个例子,您能够钦赐结果满含的是黄金年代体 Customer 对象、仅贰个分子、成员的子集,仍然某些基于计算或新对象创立的完全两样的结果类型。当 select 子句生成除源成分别本以外的内容时,该操作称为“投影”。

 

var evenNumQuery = 
    from num in numbers
    where (num % 2) == 0
    select num;
int evenNumCount = evenNumQuery.Count();

三、使用 LINQ 进行数量转变

  语言集成查询 (LINQ) 不止可用于检索数据,并且照旧二个功效强盛的多少转变工具。通过运用 LINQ 查询,您能够将源系列用作输入,并行使七种措施修改它以创办新的输出系列。您能够由此排序和分组来改革该种类,而不必匡正成分自个儿。可是,LINQ 查询的最刚劲的作用是力所能致创设新品类。那意气风发效应在 select 子句中达成。 比方,能够施行下列职务:  

  

三、使用 LINQ 实行多少调换

  语言集成查询 (LINQ) 不唯有可用来检索数据,並且仍然四个效率强盛的多寡转变工具。通过利用 LINQ 查询,您可以将源系列用作输入,并采取各个办法校正它以创建新的输出系列。您能够经过排序和分组来校订该种类,而不要改正成分本人。不过,LINQ 查询的最有力的功力是力所能致创制新品类。那生龙活虎效应在 select 子句中达成。 举个例子,能够施行下列任务:  

  

     若要强制立时执行大肆查询并缓存其结果,能够调用 ToList<TSource> 或 ToArray<TSource> 方法。

  3.1 将三个输入联接到叁个输出体系

图片 47图片 48

 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     }

学子和名师七个类

图片 49图片 50

 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.1 将八个输入联接到贰个出口连串

图片 51 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 } 学子和教授八个类 图片 52 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 } 调整台出口代码。

图片 53

 

List<int> numQuery2 =
    (from num in numbers
     where (num % 2) == 0
     select num).ToList();

  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.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};

 

  • 支持 LINQ 的功能
    • 询问表明式

  3.3 将内部存储器中的对象调换为 XML

图片 54图片 55

 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

图片 56

 

  3.3 将内存中的靶子调换为 XML

图片 57 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

图片 58

 

     查询表明式使用近似于 SQL 或 XQuery 的证明性语法来询问 IEnumerable 集结。在编写翻译时,查询语法调换为对 LINQ 提供程序的正式查询运算符增加方法完毕的办法调用。应用程序通过采用 using 指令钦定适当的命名空间来决定范围内的标准查询运算符。上边包车型地铁询问表明式获取贰个字符串数组,按字符串中的第二个字符对字符串举办分组,然后对各组实行排序。

  3.4 对源成分推行操作

  输出类别也许不包蕴源类别的任何因素或因素属性。输出大概是透过将源元素用作输入参数计算出的值的队列。

图片 59图片 60

 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

图片 61

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

 

  3.4 对源成分推行操作

  输出体系大概不分包源系列的其余因素或因素属性。输出恐怕是经过将源成分用作输入参数总括出的值的行列。

图片 62 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

图片 63

 

var query = from str in stringArray
            group str by str[0] into stringGroup
            orderby stringGroup.Key
            select stringGroup;

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

  LINQ 查询操作在数据源、查询本身及查询实施中是强类型的。查询中变量的等级次序必需与数据源瓜时素的档期的顺序和 foreach 语句中迭代变量的类型宽容。强类型能够确定保证在编写翻译时捕获类型错误,以便及时修正。

 

四、LINQ 查询操作的花色涉及

  LINQ 查询操作在数据源、查询自个儿及查询试行中是强类型的。查询中变量的类型必需与数据源中元素的类型和 foreach 语句中迭代变量的花色宽容。此强类型保障在编写翻译时捕获类型错误,以便能够在客商蒙受那几个错误以前改善它们。

 

    • 隐式类型化变量

  4.1 不转换源数据的询问

  下图演示不对数据实行转变的 LINQ to Objects 查询操作。源富含叁个字符串连串,查询输出也是贰个字符串体系。 

图片 64

  ①数据源的门类参数决定约束变量的项目。

  ②选项的靶子的档期的顺序决定查询变量的体系。此处的 name 为二个字符串。因而,查询变量是二个 IEnumerable<字符串>。  

  ③在 foreach 语句中循环访谈查询变量。因为查询变量是叁个字符串种类,所以迭代变量也是一个字符串。  

 

  4.1 不调换源数据的询问

  下图演示不对数据举办转变的 LINQ to Objects 查询操作。源包涵八个字符串体系,查询输出也是多少个字符串系列。 

图片 65

  (1)数据源的档次参数决定约束变量的类别。

  (2)接收的对象的类型决定查询变量的门类。此处的 name 为四个字符串。由此,查询变量是叁个 IEnumerable<字符串>。  

  (3)在 foreach 语句中循环访谈查询变量。因为查询变量是多个字符串类别,所以迭代变量也是一个字符串。  

 

     不必在表明并开首化变量时显式钦点项目,您能够利用 var 修饰符来提示编译器预计并分配项目,申明为 var 的变量与显式钦命其系列的变量同样都以强类型。通过运用 var,能够创立无名氏类型,但它可用来其余部分变量。也足以动用隐式类型表明数组。

  4.2 转变源数据的查询

  下图演示对数码实行轻巧调换的 LINQ to SQL 查询操作。查询将四个 Customer 对象类别用作输入,并只接收结果中的 Name 属性。因为 Name 是二个字符串,所以查询生成二个字符串类别作为出口。  

图片 66

  ①数据源的档期的顺序参数决定限定变量的档期的顺序。

  ②select 语句再次来到 Name 属性,而非完整的 Customer 对象。因为 Name 是二个字符串,所以 custNameQuery 的门类参数是 string,而非Customer。  

  ③因为 custNameQuery 是叁个字符串种类,所以 foreach 循环的迭代变量也必须要是 string

 

  下图演示另风度翩翩种转移。select 语句再次回到只捕获原始 Customer 对象的五个分子的无名类型。

图片 67

  ①数据源的连串参数始终为查询中的范围变量的连串。

  ②因为 select 语句生成无名氏类型,所以必需利用 var 隐式类型化查询变量。

  ③因为查询变量的体系是隐式的,所以 foreach 循环中的迭代变量也不得不是隐式的。

 

  4.2 转变源数据的查询

  下图演示对数码进行轻巧转变的 LINQ to SQL 查询操作。查询将叁个 Customer 对象系列用作输入,并只选拔结果中的 Name 属性。因为 Name 是三个字符串,所以查询生成三个字符串种类作为出口。  

图片 68

  (1)数据源的花色参数决定节制变量的档案的次序。

  (2)select 语句重返 Name 属性,而非完整的 Customer 对象。因为 Name 是二个字符串,所以 custNameQuery 的门类参数是 string,而非Customer。  

  (3)因为 custNameQuery 是四个字符串类别,所以 foreach 循环的迭代变量也必须要是 string

 

  下图演示另意气风发种转移。select 语句重回只捕获原始 Customer 对象的三个成员的无名氏类型。

图片 69

  (1)数据源的类别参数始终为查询中的范围变量的连串。

  (2)因为 select 语句生成无名类型,所以必需利用 var 隐式类型化查询变量。

  (3)因为查询变量的系列是隐式的,所以 foreach 循环中的迭代变量也亟须是隐式的。

 

var number = 5;
var name = "Virginia";
var query = from str in stringArray
            where str[0] == 'm'
            select str;

  4.3 让编写翻译器猜想类型新闻

  您也足以动用重要字 var,可用以查询操作中的任何部分变量。可是,编写翻译器为查询操作中的种种变量提供强类型。  

图片 70

 

  4.3 让编写翻译器测度类型新闻

  您也能够选择让编写翻译器为您履行总体育专科高校门的学业。关键字 var 可用于查询操作中的任何部分变量。然则,编写翻译器为查询操作中的各个变量提供强类型。  

图片 71

 

    • 对象和集结开端值设定项

五、LINQ 中的查询语法和措施语法

  我们编辑的 LINQ 查询语法,在编译代码时,CLLX570会将查询语法变换为艺术语法。这一个措施调用标准查询运算符的称号近似 WhereSelectGroupByJoinMax和 Average,我们也是能够直接利用那么些点子语法的。  

  查询语法和方保加奥马哈语意大利语义相通,可是,许四人士开采查询语法更简约、更易于阅读。有个别查询必须代表为方式调用。举个例子,必得利用方法调用表示检索成分的多少与钦赐的规范化的询问。还非得运用方式须求查究元素的最大值在源连串的查询。System.Linq 命名空间中的标准查询运算符的参谋文书档案日常选用情势语法。

 

五、LINQ 中的查询语法和章程语法

  在象征语言集成查询 (LINQ) 使用 LINQ 性查询语法,文书档案中的许多查询编写。但是,编写翻译代码时,必得将查询语法调换为形式,那就须要.NET 公共语言运转时 (CL本田CR-V)。那个点子调用标准查询运算符的称谓相近 WhereSelectGroupByJoinMax和 Average。能够调用那么些格局直接行使办朝鲜语法实际不是查询语法。  

  查询语法和艺术语马耳他语义相近,但是,许几个人口开掘查询语法更轻松、更易于阅读。有个别查询必得代表为形式调用。举个例子,必需利用格局调用表示检索成分的数额与钦定的条件的询问。还非得采用办法须要搜索成分的最大值在源系列的询问。System.Linq 命名空间中的标准查询运算符的参阅文书档案日常使用方爱尔兰语法。

 

     通过对象和集结开头值设定项,起头化对象时不供给为目的显式调用构造函数。最早值设定项普通用在将源数据投影到新数据类型的询问表明式中。假定贰个类名叫Customer,具备公共 Name 和 Phone 属性,能够按下列代码中所示使用对象开头值设定项:

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

图片 72图片 73

 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         }

下边包车型大巴示范演示轻便的询问表明式和编写制定为依靠方法的询问的语义上等效的查询。

图片 74

  八个示范的出口是同等的。您能够见到三种方式的询问变量的种类是平等的:IEnumerable<T>。  

  若要领悟基于方法的查询,让大家越发地深入分析它。注意,在表明式的动手,where 子句今后意味着为对 numbers 对象的实例方法,在您再也调用该指标时其连串为 IEnumerable<int>。假如你熟谙泛型 IEnumerable<T> 接口,那么你就能够询问,它不具有 Where 方法。不过,尽管你在 Visual Studio IDE 中调用 速龙liSense 达成列表,那么您不只将见到 Where 方法,并且还有恐怕会看出多数其余措施,如 SelectSelectManyJoin 和Orderby。上边是有所职业查询运算符。 

图片 75

  固然看起来 IEnumerable<T> 宛如已被再度定义以囊括这一个附加措施,但实在其实不然。那个专门的学问查询运算符都以充任“扩展方法”完结的。

 

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

图片 76 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 } 上边的示范演示轻易的查询表明式和编写制定为借助方法的询问的语义上等效的查询。

图片 77

  四个示范的出口是千篇一律的。您能够看出两种样式的询问变量的体系是千篇大器晚成律的:IEnumerable<T>。  

  若要了然基于方法的询问,让大家更是地深入分析它。注意,在表明式的左手,where 子句现在乎味着为对 numbers 对象的实例方法,在你再一次调用该目的时其品种为 IEnumerable<int>。假设你纯熟泛型 IEnumerable<T> 接口,那么你就能驾驭,它不持有 Where 方法。不过,若是您在 Visual Studio IDE 中调用 英特尔liSense 完成列表,那么你不仅仅将见到 Where 方法,何况还拜谒到不计其数别样艺术,如 SelectSelectManyJoin 和Orderby。上面是怀有标准查询运算符。 

图片 78

  即便看起来 IEnumerable<T> 就像是已被再次定义以囊括这个附加措施,但事实上其实不然。这几个标准查询运算符都是作为“扩充方法”达成的。

 

Customer cust = new Customer { Name = "Mike", Phone = "555-1212" };

  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.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,所以你可通过将艺术调用链接在一块,在情势语法上校这么些查询组合起来。那就是在你通过利用查询语法编写查询时编写翻译器在后台所实行的操作。并且由于查询变量不存款和储蓄查询的结果,因而你能够每一日修改它或将它用作新查询的根基,尽管在进行它后。

 

  5.3 查询的组合性

  在上边的代码示例中,请小心 OrderBy 方法是由此在对 Where 的调用中应用点运算符来调用的。Where 生成挑选种类,然后 Orderby 通过对该系列排序来对它进行操作。因为查询会再次来到 IEnumerable,所以你可经过将艺术调用链接在同步,在艺术语法上将这么些查询组合起来。那就是在您通过接受查询语法编写查询时编写翻译器在后台所进行的操作。何况鉴于查询变量不存款和储蓄查询的结果,由此你能够随即改过它或将它用作新查询的根底,固然在实行它后。

 

本文首联:

 

--待收拾形成后再也揭橥到首页--

  

] 开始利用 LINQ, 早先接受 LINQ 在此以前曾公布过三篇关于 LINQ 的小说: 进级:《LINQ 规范查询操作概述》 (刚烈推荐) 技术:《Linq...

     无名类型由编写翻译器创设,且项目名称只可用以编写翻译器。佚名类型提供了生机勃勃种在查询结果中一时分组生机勃勃组属性的福利方法,无需定义单独的命名类型。使用新的表达式和对象伊始值设定项初步化无名氏类型。

传送门

  入门:《走进 LINQ 的世界》

  进阶:《LINQ 规范查询操作概述》(猛烈推荐)

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

 

 


正文首联:

【参考】 等

【来源】本文援引部分微软官方文书档案的图片

 

 

  

select new {name = cust.Name, phone = cust.Phone};
    • 扩展方法

     扩张方法是大器晚成种可与品类涉及的静态方法,由此可以像实例方法那样对品种调用它。实际上,此意义让你能够将新措施“增添”到存活项目,而不会实际修正它们。标准查询运算符是风流洒脱组扩展方法,它们为达成IEnumerable<T> 的任何项目提供 LINQ 查询功效。

    • Lambda 表达式

     Lambda 表明式是黄金时代种内联函数,该函数使用 => 运算符将输入参数与函数体分离,而且可以在编写翻译时转变为委托或公布式树。在 LINQ 编制程序中,在您对标准查询运算符举办直接格局调用时,会遇见 lambda 表明式。

    • 机动落成的习性

     通过机关完结的性质,能够更引人瞩目地声称属性。当您如下边包车型客车演示中所示评释属性时,编译器将创制叁个个体的佚名支持字段,该字段只可以通过性能getter 和 setter 实行访问。

public string Name {get; set;}
  • LINQ 泛型
    •  IEnumerable<T> 变量

     LINQ 查询变量类型化为 IEnumerable<T> 或派生类型,如 IQueryable<T>。当你收看类型化为 IEnumerable<Customer> 的询问变量时,那只表示在进行该查询时,该查询将扭转包含零个或三个Customer 对象的队列。

IEnumerable<Customer> customerQuery =
    from cust in customers
    where cust.City == "London"
    select cust;
foreach (Customer customer in customerQuery)
{
    Console.WriteLine(customer.LastName   ", "   customer.FirstName);
}
    • 编写翻译器管理泛型类型证明

     如若你愿意,能够运用 var 关键字来防止选择泛型语法。 var 关键字提醒编写翻译器通过查阅在 from 子句中钦定的数额源来估摸查询变量的门类。当变量的项目显著或显式钦赐嵌套泛型类型(如由组查询生成的这个类型)并不重要时,var 关键字很有用。常常,大家提出后生可畏旦你使用 var,应意识到那说不定让你的代码更麻烦让外人精通。

var customerQuery2 = 
    from cust in customers
    where cust.City == "London"
    select cust;
foreach(var customer in customerQuery2)
{
    Console.WriteLine(customer.LastName   ", "   customer.FirstName);
}
  • LINQ to Objects

     术语“LINQ to Objects”是指直接对任性IEnumerable 或 IEnumerable<T> 会集使用 LINQ 查询,不必要使用个中LINQ 提供程序或 API,如 LINQ to SQL 或 LINQ to XML。 能够选拔 LINQ 来询问任何可枚举的聚众,如 List<T>、Array 或 Dictionary<TKey, 电视alue>。 该集结能够是客商定义的集纳,也足以是 .NET Framework API 重回的集纳。

     从根本上说,LINQ to Objects 表示风流罗曼蒂克种新的管理集结的章程。 选择旧办法,您必需编写制定钦点怎样从集结检索数据的复杂性的 foreach 循环。 而使用 LINQ 方法,您只需编写描述要探究的剧情的评释性代码。

     其它,与价值观的 foreach 循环比较,LINQ 查询全部三大优势:

    • 它们更显眼、更易读,特别在筛选两个标准期。
    • 它们选择起码的应用程序代码提供刚劲的筛选、排序和分组功用。
    • 不要修改或只需做一点都不大的改造就能够将它们移植到其它数据源。

本文由pc28.am发布于计算机编程,转载请注明出处:开始使用

上一篇:如何在手机上实现饼图图表 下一篇:没有了
猜你喜欢
热门排行
精彩图文