走进 LINQ 的世界

走进 LINQ 的世界

[C#] 初阶运用 LINQ,

 

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

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

    技巧:《Linq To Objects –
怎么样操作字符串》 和
《金沙注册送58,Linq To Objects –
怎样操作文件目录》

  未来,自身打算再整治壹篇有关 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 简介
  • 介绍 LINQ
    查询
  • LINQ
    基本查询操作
  • 选取 LINQ
    实行多少转换
  • LINQ
    查询操作的门类涉及
  • LINQ
    中的查询语法和方保加利亚语法

 

  语言集成查询 (LINQ) 是 Visual Studio 二零零六 和 .NET Framework 叁.伍版中引进的一项创新功效。

  守旧上,针对数据的查询都以以简要的字符串表示,而并未有编写翻译时类型检查或
速龙liSense
协助。别的,您还必须针对以下种种数据源学习壹种分化的询问语言:SQL
数据库、XML 文书档案、各类 Web 服务等等。 通过LINQ,
您能够采纳语言关键字和熟稔的演算符针对强类型化对象集合编写查询。

金沙注册送58 1

  

  在 Visual Studio 中,能够为以下数据源编写 LINQ 查询:SQL Server
数据库、XML 文书档案、ADO.NET
数据集,以及协助 IEnumerable 或泛型 IEnumerable<T> 接口的任意对象集合。
  使用供给:项目 ≥ .NET Framework 三.5 。  

     语言集成查询 (LINQ) 是 Visual Studio
二零零六 中引进的1组成效,它在目的领域和数据领域里面架起了一座桥梁。可为
C# 和 Visual Basic 语言语法提供强劲的查询成效。 LINQ
引进了正式、易学的数码查询和换代形式,该技术能够扩展为大概扶助别的项目标多少存款和储蓄。Visual
Studio 包罗 LINQ 提供程序的程序集,借助这几个程序集,就能将 LINQ 用于 .NET
Framework 集合、SQL Server 数据库、ADO.NET 数据集和 XML 文书档案。

LINQ 简介

  语言集成查询 (LINQ) 是 Visual Studio 二〇〇八 和 .NET Framework 三.五版中引进的1项立异功效。

  守旧上,针对数据的询问都以以简要的字符串表示,而并未有编写翻译时类型检查或
AMDliSense
扶助。其它,您还非得针对以下各样数据源学习一种区别的查询语言:SQL
数据库、XML 文书档案、种种 Web 服务等等。 通过LINQ,
您能够运用语言关键字和熟习的演算符针对强类型化对象集合编写查询。

金沙注册送58 2

  

  在 Visual Studio 中,能够为以下数据源编写 LINQ 查询:SQL Server
数据库、XML 文书档案、ADO.NET
数据集,以及支持 IEnumerable 或泛型 IEnumerable<T> 接口的4意对象集合。

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

 

LINQ 简介

  语言集成查询 (LINQ) 是 Visual Studio 200玖 和 .NET Framework 三.伍版中引进的一项创新成效。

  守旧上,针对数据的查询都是以简练的字符串表示,而从未编写翻译时类型检查或
英特尔liSense
协理。其它,您还非得针对以下各类数据源学习1种分裂的查询语言:SQL
数据库、XML 文书档案、种种 Web 服务等等。 通过LINQ,
您可以动用语言关键字和熟习的运算符针对强类型化对象集合编写查询。

金沙注册送58 3

  

  在 Visual Studio 中,能够为以下数据源编写 LINQ 查询:SQL Server
数据库、XML 文书档案、ADO.NET
数据集,以及补助 IEnumerable 或泛型 IEnumerable<T> 接口的4意对象集合。

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

 

目录

  • 介绍 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
通过提供1种跨数据源和数量格式使用数据的同样模型,简化了那一情景。在
LINQ 查询中,始终会用到对象。能够采用相同的编码情势来询问和更换 XML
文书档案、SQL 数据库、ADO.NET 数据集、.NET 集合中的数据以及对其有 LINQ
提供程序可用的任何别的格式的数额。  

 

一、介绍 LINQ 查询

  查询是壹种从数据源检索数据的表明式。随着时光的延迟,人们早已为种种数据源开发了不一致的语言;例如,用于关周到据库的
SQL 和用来 XML 的
XQuery。因而,开发人士不得不针对他们必须帮忙的每个数据源或数量格式而学习新的询问语言。LINQ
通过提供1种跨数据源和数码格式使用数据的如出壹辙模型,简化了那1景色。在
LINQ 查询中,始终会用到对象。能够运用相同的编码格局来询问和转换 XML
文书档案、SQL 数据库、ADO.NET 数据集、.NET 集合中的数据以及对其有 LINQ
提供程序可用的别样其余格式的数额。  

 

一、介绍 LINQ 查询

  查询是一种从数据源检索数据的表明式。随着年华的延期,人们一度为各个数据源开发了分裂的言语;例如,用于关全面据库的
SQL 和用于 XML 的
XQuery。由此,开发职员不得不针对他们不能够不支持的种种数据源或数量格式而学习新的询问语言。LINQ
通过提供壹种跨数据源和多少格式使用数据的平等模型,简化了那一状态。在
LINQ 查询中,始终会用到目的。可以利用同样的编码形式来查询和转移 XML
文书档案、SQL 数据库、ADO.NET 数据集、.NET 集合中的数据以及对其有 LINQ
提供程序可用的其余此外格式的多少。  

     查询是1种从数据源检索数据的表明式。
查询普通用专门的询问语言来代表。
随着时光的延期,人们早已为各类数据源开发了差异的言语;例如,用于关周详据库的
SQL 和用来 XML 的 XQuery。
由此,开发人士不得不针对他们必须帮衬的每一种数据源或数额格式而上学新的查询语言。
LINQ
通过提供1种跨各样数据源和数码格式使用数据的同等模型,简化了那一景观。
在 LINQ 查询中,始终会用到指标。 能够应用相同的大旨编码形式来查询和转换
XML 文档、SQL 数据库、ADO.NET 数据集、.NET 集合中的数据以及对其有 LINQ
提供程序可用的其余别的格式的数量。

  1.1 查询操作的七个部分

  操作三部曲:一取多少源 二创立查询 叁执行查询

金沙注册送58 4金沙注册送58 5

 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

金沙注册送58 6

 

   下图显示了完全的询问操作。在 LINQ
中,查询的实践与查询本人截然区别;换句话说,查询自个儿指的是只开创查询变量,不检索任何数据。

金沙注册送58 7

  

  1.一 查询操作的五个部分

  操作3部曲:一取多少源 贰开立查询 3实施查询

金沙注册送58 8金沙注册送58 9

 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

金沙注册送58 10

 

   下图展现了全部的查询操作。在 LINQ
中,查询的实施与查询本人截然不相同;换句话说,查询自身指的是只创设查询变量,不检索任何数据。

金沙注册送58 11

  

  一.一 查询操作的多个部分

  操作3部曲:1取多少源 贰创办查询 3实践查询

金沙注册送58 12 1 internal
class Program 2 { 3 private static void Main(string[] args) 四 { 5
//一.获取数据源 6 var nums = new int[7] { 0, 一, 二, 3, 四, 5, 6 }; 柒 8
//2.创立查询 九 var numQuery = 十 from num in nums 1一 where (num % 二) ==
0 1贰 select num; 一三 1四 //三.执行查询 一5 foreach (var num in numQuery) 16{ 1⑦ Console.WriteLine(“{0}”, num); 18 } 19 } 20 } View Code

金沙注册送58 13

 

   下图展现了1体化的询问操作。在 LINQ
中,查询的施行与查询自身截然分裂;换句话说,查询本人指的是只创设查询变量,不检索任何数据。

金沙注册送58 14

  

金沙注册送58 15

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

金沙注册送58 16金沙注册送58 17

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

金沙注册送58 18金沙注册送58 19

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

金沙注册送58 201 var db =
new Northwnd(@”c:\northwnd.mdf”); 2 3 //查询在London的客户 四 var
custQuery = 5 from cust in db.Customers 6 where cust.City == “London” 七select cust; Customers 表示数据库中的特定表

 

 

  1.3 查询

  查询内定要从数据源中检索的新闻。
查询还足以钦点在回来那些消息在此之前怎么着对其开始展览排序、分组和结构化。
查询存款和储蓄在询问变量中,并用查询表明式实行起先化。

  之前的演示中的查询是从整数数组中回到全部的偶数。
该查询表明式包蕴多个子句:fromwhere 和 select。(若是您熟知SQL,您会专注到那几个子句的逐一与 SQL
中的顺序相反。)from 子句指定数据源,where 子句钦赐应用筛选器,select 子句钦赐重返的要素的连串。
近来亟待留意的是,在 LINQ 中,查询变量本人不执行此外操作并且不回来任何数据。
它只是存款和储蓄在随后有些时刻执行查询时为转变结果而须要的音信。

 

  1.3 查询

  查询内定要从数据源中检索的音讯。
查询还足以内定在回到这么些消息在此之前怎么样对其进行排序、分组和结构化。
查询存款和储蓄在询问变量中,并用查询表明式进行开头化。

  在此以前的示范中的查询是从整数数组中回到全部的偶数。
该查询表达式包涵多少个子句:fromwhere 和 select。(假设您熟知SQL,您会小心到这一个子句的顺序与 SQL
中的顺序相反。)from 子句内定数据源,where 子句钦赐应用筛选器,select 子句钦定再次来到的要素的项目。
最近亟待专注的是,在 LINQ 中,查询变量本人不举行别的操作并且不回去任何数据。
它只是存款和储蓄在事后某些时刻执行查询时为转变结果而要求的信息。

 

  1.3 查询

  查询钦点要从数额源中检索的新闻。
查询还可以够内定在重返那么些消息在此以前如何对其进展排序、分组和结构化。
查询存款和储蓄在查询变量中,并用查询表明式进行开始化。

  以前的言传身教中的查询是从整数数组中回到全数的偶数。
该查询表明式包罗四个子句:fromwhere 和 select。(要是您熟谙SQL,您会专注到那么些子句的依次与 SQL
中的顺序相反。)from 子句钦点数据源,where 子句钦定应用筛选器,select 子句钦点重回的要素的花色。
近期亟待留意的是,在 LINQ
中,查询变量本人不执行其余操作并且不回来任何数据。
它只是存款和储蓄在之后某些时刻执行查询时为转变结果而须要的新闻。  

    • 收获数据源

  壹.四 查询执行

  一.四 查询执行

  1.4 查询执行

     LINQ语句是在 foreach
语句中执行查询,而 foreach 要求运用 IEnumerable 或
IEnumerable<T>。援助 IEnumerable<T> 或派生接口(如泛型
IQueryable<T>)的花色称为“可查询类型”。

  一.推迟执行

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

  一.延缓执行

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

  一.延缓执行

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

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

  二.威胁立时执行

    对一文山会海源成分执行聚合函数的询问必须首先循环访问这几个因素。CountMaxAverage 和 First 就属于此类查询。由于查询本人必须选拔 foreach 以便回到结果,由此那一个查询在实施时不行使显式 foreach 语句。别的还要小心,那些项指标询问再次回到单个值,而不是 IEnumerable 集合。 

金沙注册送58 21金沙注册送58 22

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

金沙注册送58 23

 

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

金沙注册送58 24金沙注册送58 25

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

 

  其余,还足以透过在紧跟查询表明式之后的职责放置1个 foreach 循环来强制执行查询。不过,通过调用 ToList 或 ToArray,也足以将享有数据缓存在单个集合对象中。 

 

  二.威吓马上实施

    对壹种类源成分执行聚合函数的询问必须首先循环访问这几个成分。CountMaxAverage 和 First 就属于此类查询。由于查询本身必须采取 foreach 以便回到结果,因而这一个查询在履行时不利用显式 foreach 语句。此外还要小心,那么些品种的查询重回单个值,而不是 IEnumerable 集合。 

金沙注册送58 26金沙注册送58 27

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

金沙注册送58 28

 

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

金沙注册送58 29金沙注册送58 30

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

 

  二.勒迫立时实施

    对1密密麻麻源成分执行聚合函数的询问必须首先循环访问那一个因素。CountMaxAverage 和 First 就属于此类查询。由于查询本身必须使用 foreach 以便回到结果,由此那些查询在实行时不应用显式 foreach 语句。其它还要小心,那些项指标查询重临单个值,而不是 IEnumerable 集合。 

金沙注册送58 311 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,也能够将所有数据缓存在单个集合对象中。 

 

    • 成立查询

2、基本 LINQ 查询操作

贰、基本 LINQ 查询操作

贰、基本 LINQ 查询操作

     查询钦定要从数量源中检索的音讯。查询还足以内定在回来这么些音信在此以前怎样对其开始展览排序、分组和结构化。查询存款和储蓄在询问变量中,并用查询表明式举办开首化。

  二.一 获取数据源:from

  在 LINQ
查询中,第2步是点名数据源。像在大部编程语言中千篇壹律,必须先表明变量,才能使用它。在
LINQ 查询中,起初使用 from 子句的指标是引进数据源和限制变量。

金沙注册送58 32金沙注册送58 33

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

View Code

  范围变量类似于 foreach 循环中的迭代变量,但在查询表达式中,实际上不发出迭代。执行查询时,范围变量将用作对 customers 中的每一种后续成分的引用。因为编译器能够臆想 cust 的类别,所以您不要显式内定此类型。

 

  二.一 获取数据源:from

  在 LINQ
查询中,第一步是点名数据源。像在多数编制程序语言中相同,必须先评释变量,才能应用它。在
LINQ 查询中,发轫使用 from 子句的指标是引入数据源和限量变量。

金沙注册送58 34金沙注册送58 35

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
查询中,第3步是钦点数据源。像在大部分编制程序语言中相同,必须先注脚变量,才能应用它。在
LINQ 查询中,起先使用 from 子句的指标是引进数据源和界定变量。

金沙注册送58 361
//queryAllCustomers 是 IEnumerable<Cutsomer> 类型 二 //数据源
(customers) 和范围变量 (cust) 3 var queryAllCustomers = from cust in
customers 四 select cust; View
Code

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

 

    • 实行查询
      • 延期执行

  2.2 筛选:where

  只怕最常用的询问操作是行使布尔表达式情势的筛选器。此筛选器使查询只回去那多少个表明式结果为
true 的因素。使用 where 子句生成结果。实际上,筛选器内定从源种类中清除哪些要素。

金沙注册送58 37金沙注册送58 38

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

只回去地址位于London的 customers。

  您能够行使深谙的 C#
逻辑 AND(&&)和 OR(||) 运算符来依据需求在 where 子句中利用任意数量的筛选表达式。 

金沙注册送58 39金沙注册送58 40

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

若要只回去位于“London”和姓名称为“Devon”的客户

金沙注册送58 41金沙注册送58 42

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

若要再次来到位于London或巴黎的客户

 

  2.2 筛选:where

  只怕最常用的查询操作是应用布尔表明式格局的筛选器。此筛选器使查询只回去那几个表达式结果为
true 的要素。使用 where 子句生成结果。实际上,筛选器内定从源系列中清除哪些要素。

金沙注册送58 43金沙注册送58 44

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

只回去地址位于伦敦的 customers。

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

金沙注册送58 45金沙注册送58 46

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

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

金沙注册送58 47金沙注册送58 48

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

若要再次回到位于London或香水之都的客户

 

  2.2 筛选:where

  恐怕最常用的询问操作是采取布尔表达式格局的筛选器。此筛选器使查询只回去那多少个表明式结果为
true
的元素。使用 where 子句生成结果。实际上,筛选器内定从源系列中消除哪些因素。

金沙注册送58 49一 var
queryLondonCustomers = from cust in customers 二        where
cust.City = “London” 3       select cust; 只回去地址位于London的 customers。

  您能够接纳深谙的 C#
逻辑 AND(&&)和 OR(||) 运算符来依据要求在 where 子句中运用任意数量的筛选表达式。 

金沙注册送58 50where
cust.City = “London” && cust.Name = “Devon” 若要只回去位于“London”和姓名称叫“Devon”的客户
金沙注册送58 51where
cust.City = “London” || cust.Name = “Paris” 若要回到位于London或巴黎的客户

 

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

  2.3 排序:orderby

  常常可以很有益于地将赶回的数额举办排序。orderby 子句将使重回的系列中的成分遵照被排序的档次的暗中同意比较器举行排序。

金沙注册送58 52金沙注册送58 53

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 子句将使重回的行列中的成分依据被排序的花色的暗许相比器进行排序。

金沙注册送58 54金沙注册送58 55

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

按 Name 属性对结果开始展览排序

  因为 Name 是3个字符串,所以暗中认可比较器执行从 A 到 Z
的假名排序。若要按相反顺序(从 Z 到 A)对结果进行排序,请使用 orderby…descending 子句。

 

  2.3 排序:orderby

  平常能够很方便地将重回的数码进行排序。orderby 子句将使重回的队列中的成分依据被排序的门类的暗许比较器举办排序。

金沙注册送58 56一 var
queryLondonCustomers = from cust in customers 2 where cust.City =
“London” 三 orderby cust.Name descending ④ select cust; 按 Name 属性对结果开始展览排序

  因为 Name 是2个字符串,所以私下认可比较器执行从 A 到 Z
的字母排序。若要按相反顺序(从 Z 到 A)对结果开展排序,请使用 orderby…descending 子句。

 

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

  2.4 分组:group

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

金沙注册送58 57金沙注册送58 58

 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 子句甘休查询时,结果使用列表的列表情势。列表中的各种成分是1个负有 Key 成员及依照该键分组的要素列表的目的。在循环访问生成组连串的询问时,您必须选取嵌套的 foreach 循环。外部循环用于循环访问每一种组,内部循环用于循环访问每种组的分子。
 

  倘诺你必须引用组操作的结果,能够选拔 into 关键字来创立可进一步查询的标识符。

金沙注册送58 59金沙注册送58 60

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 子句,您能够按内定的键分组结果。

金沙注册送58 61金沙注册送58 62

 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 关键字来创建可进一步询问的标识符。

金沙注册送58 63金沙注册送58 64

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 子句,您能够按内定的键分组结果。

金沙注册送58 65 1 var
queryLondonCustomers = from cust in customers 二 group cust by cust.City;
叁 四 foreach (var queryLondonCustomer in queryLondonCustomers) 伍 { 6Console.WriteLine(queryLondonCustomer.Key); 7 foreach (var cust in
queryLondonCustomer) 捌 { 九 Console.WriteLine(cust.Name); 10 } 1一 } 您能够钦命结果应按 City
分组,以便位于London或法国巴黎的有所客户位于各自己组建中。

  在本例中,cust.City 是键。

  在使用 group 子句结束查询时,结果运用列表的列表方式。列表中的各样成分是3个独具 Key 成员及基于该键分组的成分列表的靶子。在循环访问生成组类别的查询时,您必须接纳嵌套的 foreach 循环。外部循环用于循环访问各样组,内部循环用于循环访问每一个组的积极分子。
 

  倘若你必须引用组操作的结果,能够利用 into 关键字来创设可进一步询问的标识符。

金沙注册送58 661
//custQuery 是 IEnumable<IGrouping<string, Customer>> 类型 二var custQuery = from cust in customers 3 group cust by cust.City 4 into
custGroup 伍 where custGroup.Count() > 二 六 orderby custGroup.Key 七select custGroup; 那里的查询只回去这一个带有三个以上的客户的组。

 

      • 强制立时施行

  2.5 联接:join

  联接运算创造数量源中未有显式建立模型的队列之间的涉嫌。例如,您可以进行联接来搜寻位于同一地方的有着客户和经销商。在
LINQ 中,join 子句始终对准对象集合而非直接指向数据库表运转。  

金沙注册送58 67金沙注册送58 68

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
中的外键在对象模型中象征为含有项集合的属性。

金沙注册送58 69金沙注册送58 70

    from order in Customer.Orders...

比如,Customer 对象涵盖 Order
对象的集聚。不必执行联接,只需使用点表示法访问订单。

  

  2.5 联接:join

  联接运算创建数量源中没有显式建立模型的队列之间的关联。例如,您能够执行联接来搜寻位于同1地点的具有客户和经销商。在
LINQ 中,join 子句始终对准对象集合而非直接指向数据库表运营。  

金沙注册送58 71金沙注册送58 72

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

诸如,您能够执行联接来寻找位于同1地点的兼具客户和经销商。

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

  在 LINQ 中,您不要像在 SQL 中那么往往使用 join,因为 LINQ
中的外键在对象模型中意味为带有项集合的习性。

金沙注册送58 73金沙注册送58 74

    from order in Customer.Orders...

譬如说,Customer 对象涵盖 Order
对象的集纳。不必执行联接,只需使用点表示法访问订单。

  

  2.5 联接:join

  联接运算创制数量源中未有显式建立模型的体系之间的关联。例如,您能够执行联接来寻找位于同1地址的持有客户和经销商。在
LINQ 中,join 子句始终对准对象集合而非直接指向数据库表运营。  

金沙注册送58 75壹 var
innerJoinQuery = from cust in customers 二   join dist in distributors
on cust.City equals dist.City 三   select new {CustomerName =
cust.Name, DistributorName = dist.Name}; 例如,您能够进行联接来寻找位于同一地址的富有客户和经销商。

  在 LINQ 中,join 子句始终对准对象集合而非直接针对数据库表运行。
 

  在 LINQ 中,您不要像在 SQL 中那么频仍使用 join,因为 LINQ
中的外键在对象模型中表示为带有项集合的习性。

金沙注册送58 76 from order
in Customer.Orders… 例如,Customer
对象涵盖 Order
对象的聚众。不必执行联接,只需使用点表示法访问订单。

  

   
 对1密密麻麻源成分执行聚合函数的询问必须首先循环访问这几个成分。
Count、马克斯、Average 和 First 就属于此类查询。由于查询本人必须运用
foreach 以便回到结果,由此这个查询在实施时不行使显式 foreach
语句。其余还要小心,这么些品种的查询重返单个值,而不是 IEnumerable
集合。

  2.6 选择(投影):select

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

  例如,您能够钦点结果包罗的是整整 Customer 对象、仅贰个成员、成员的子集,依旧某些基于计算或新指标成立的通通两样的结果类型。当 select 子句生成除源成分副本以外的内容时,该操作称为“投影”。

 

  2.6 选择(投影):select

  select 子句生成查询结果并钦定各个重回的成分的“形状”或项目。

  例如,您能够钦赐结果包蕴的是成套 Customer 对象、仅三个分子、成员的子集,依然有个别基于总计或新对象创制的完全差异的结果类型。当 select 子句生成除源元素副本以外的内容时,该操作称为“投影”。

 

  2.6 选择(投影):select

  select 子句生成查询结果并点名每种重回的要素的“形状”或项目。

  例如,您能够钦命结果蕴涵的是成套 Customer 对象、仅二个分子、成员的子集,依旧某些基于总计或新对象创造的一点1滴差异的结果类型。当 select 子句生成除源成分副本以外的始末时,该操作称为“投影”。

 

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

三、使用 LINQ 举行数据转换

  语言集成查询 (LINQ)
不仅可用以检索数据,而且照旧贰个功效强大的数目转换工具。通过使用 LINQ
查询,您能够将源种类用作输入,并利用各类主意修改它以创制新的出口种类。您能够通过排序和分组来修改该类别,而毋庸修改成分本人。然而,LINQ
查询的最精锐的法力是能够成立新类型。那1功用在 select 子句中落实。 例如,能够实施下列任务:  

  

三、使用 LINQ 实行数据转换

  语言集成查询 (LINQ)
不仅可用来检索数据,而且依然多少个功效强大的数量转换工具。通过行使 LINQ
查询,您能够将源体系用作输入,并动用四种艺术修改它以成立新的出口系列。您能够通过排序和分组来修改该类别,而无需修改成分自己。可是,LINQ
查询的最强劲的效能是能够创造新品类。这一作用在 select 子句中落成。 例如,可以执行下列任务:  

  

三、使用 LINQ 进行数量转换

  语言集成查询 (LINQ)
不仅可用于检索数据,而且照旧2个作用强大的数据转换工具。通过应用 LINQ
查询,您能够将源体系用作输入,并利用多样方法修改它以创办新的出口系列。您能够通过排序和分组来修改该体系,而毋庸修改成分自个儿。然则,LINQ
查询的最精锐的效用是能够成立新类型。这一意义在 select 子句中落到实处。 例如,能够进行下列任务:  

  

   
 若要强制立时实施任意查询并缓存其结果,能够调用 ToList<TSource> 或
ToArray<TSource> 方法。

  叁.一 将多个输入联接到三个出口系列

金沙注册送58 77金沙注册送58 78

 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     }

学员和名师多少个类

金沙注册送58 79金沙注册送58 80

 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     }

决定台出口代码。   

 

  三.1 将五个输入联接到三个输出体系

金沙注册送58 81金沙注册送58 82

 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     }

学生和教育工小编多少个类

金沙注册送58 83金沙注册送58 84

 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     }

支配台出口代码。   

 

  三.一 将多少个输入联接到2个输出系列

金沙注册送58 85 1 class
Student 二 { 3 public string Name { get; set; } 四 五 public int Age { get;
set; } 6 7 public string City { get; set; } 八 九 public List<int>
Scores { get; set; } 拾 } 1壹 1二 class Teacher 1三 { 1肆 public int Id {
get; set; } 壹伍 1陆 public string Name { get; set; } 一7 18 public int Age
{ get; set; } 1九 20 public string City { get; set; } 二壹 2二 } 学生和教职工七个类
金沙注册送58 86 1 internal
class Program 2 { 3 private static void Main(string[] args) 肆 { 5
//创建第四个数据源 6 var students = new List<Student>() 七 { 八 new
Student() 9 { 十 Age = 二三, 11 City = “苏黎世”, 12 Name = “小C”, 一三 Scores
= new List<int>(){8伍,88,8三,玖七} 1四 }, 15 new Student() 1陆 { 1七 Age
= 1捌, 1八 City = “浙江”, 1玖 Name = “小明”, 20 Scores = new
List<int>(){8六,7捌,八五,90} 2壹 }, 2贰 new Student() 贰3 { 二4 Age = 3③,
二⑤ City = “梦中”, 二陆 Name = “小3”, 2柒 Scores = new
List<int>(){捌六,68,7叁,97} 2捌 } 2玖 }; 30 3壹 //制造第三个数据源 32var teachers = new List<Teacher>() 3三 { 3四 new Teacher() 35 { 3陆Age = 35, 3七 City = “梦中”, 3捌 Name = “啵哆” 3九 }, 40 new Teacher() 四1 {
4二 Age = 2八, 四三 City = “甘肃”, 4四 Name = “小红” 四伍 }, 四陆 new Teacher()
肆柒 { 4八 Age = 3捌, 4九 City = “辽宁”, 50 Name = “丽丽” 51 } 5二 }; 53 54
//成立查询 5五 var peopleInDreams = (from student in students 5陆 where
student.City == “梦中” 57 select student.Name) 5捌 .Concat(from teacher
in teachers 5九 where teacher.City == “梦里” 60 select teacher.Name); 61
62 //执行查询 六三 foreach (var person in peopleInDreams) 64 { 6伍Console.WriteLine(person); 6六 } 6七 6八 Console.Read(); 6九 } 70 } 控制台出口代码。

金沙注册送58 87

 

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

  三.二 选用各样源成分的子集

  一. 若要只选拔源成分的一个分子,请使用点运算。

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

  

  二. 若要创造包括源成分的多少个属性的元素,能够使用全部命名对象或匿名类型的对象伊始值设定项。

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

 

  三.二 选用种种源成分的子集

  一. 若要只接纳源成分的二个成员,请使用点运算。

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

  

  二. 若要创立包蕴源成分的三个属性的要素,能够利用全部命名对象或匿名类型的靶子初阶值设定项。

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

 

  三.贰 选用各类源成分的子集

  一. 若要只选拔源成分的1个成员,请使用点运算。

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

  

  二. 若要创造包罗源成分的五性子情的成分,能够运用全体命名对象或匿名类型的对象初步值设定项。

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

 

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

  3.3 将内部存款和储蓄器中的目的转换为 XML

金沙注册送58 88金沙注册送58 89

 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 90

 

  叁.3 将内部存款和储蓄器中的目的转换为 XML

金沙注册送58 91金沙注册送58 92

 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 93

 

  三.三 将内部存款和储蓄器中的对象转换为 XML

金沙注册送58 94 1
//成立数量源 2 var students = new List<Student>() 三 { 4 new
Student() 5 { 陆 Age = 1八, 柒 Name = “小A”, 捌 Scores = new
List<int>() {8八,八五,7四,6六 } 九 }, 拾 new Student() 1一 { 1二 Age = 3五,
一三 Name = “小B”, 1四 Scores = new List<int>() {8捌,8五,74,66 } 壹五 },
16 new Student() 一七 { 1八 Age = 2捌, 1玖 Name = “小吗”, 20 Scores = new
List<int>() {8捌,85,7四,6陆 } 二一 } 22 }; 二三 二肆 //创设查询 二伍 var
studentsToXml = new XElement(“Root”, 26 from student in students 二柒 let
x =
$”{student.Scores[0]},{student.Scores[1]},{student.Scores[2]},{student.Scores[3]}”
2捌 select new XElement(“student”, 2玖 new XElement(“Name”, student.Name),
30 new XElement(“Age”, student.Age), 31 new XElement(“Scores”, x)) 3二 );
3三 3四 //执行查询 3五 Console.WriteLine(studentsToXml); View Code

金沙注册送58 95

 

     查询表明式使用类似于 SQL 或 XQuery
的注脚性语法来查询 IEnumerable 集合。在编写翻译时,查询语法转换为对 LINQ
提供程序的正经查询运算符扩充方法实现的点子调用。应用程序通过使用 using
指令钦赐适当的命名空间来决定范围内的标准查询运算符。上边包车型客车查询表明式获取二个字符串数组,按字符串中的第壹个字符对字符串实行分组,然后对各组实行排序。

  三.四 对源成分执行操作

  输出种类可能不分包源系列的任何因素或因素属性。输出大概是通过将源成分用作输入参数总结出的值的队列。

金沙注册送58 96金沙注册送58 97

 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

金沙注册送58 98

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

 

  三.四 对源成分执行操作

  输出连串大概不带有源类别的别样因素或因素属性。输出只怕是透过将源成分用作输入参数总括出的值的连串。

金沙注册送58 99金沙注册送58 100

 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

金沙注册送58 101

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

 

  三.4 对源成分执行操作

  输出系列恐怕不含有源类别的其余因素或因素属性。输出或许是因而将源成分用作输入参数计算出的值的行列。

金沙注册送58 102 1 //数据源
2 double[] radii = {一, 2, 三}; 三 4 //创制查询 5 var query = from radius
in radii 陆 select $”{radius * radius * 3.1四}”; 7 八 //执行查询 九foreach (var i in query) 10 { 11 Console.WriteLine(i); 1二 } View Code

金沙注册送58 103

 

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、LINQ 查询操作的档次涉及

  LINQ
查询操作在数据源、查询本身及查询执行中是强类型的。查询中变量的类型必须与数据源瓜月素的门类和 foreach 语句中迭代变量的花色包容。此强类型保险在编写翻译时捕获类型错误,以便可以在用户遭逢这个错误从前校正它们。

 

    • 隐式类型化变量

  四.一 不转换源数据的询问

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

金沙注册送58 104

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

  二取舍的对象的花色决定查询变量的花色。此处的 name 为3个字符串。因而,查询变量是1个 IEnumerable<字符串>。
 

  ③在 foreach 语句中循环访问查询变量。因为查询变量是贰个字符串连串,所以迭代变量也是贰个字符串。
 

 

  四.一 不转换源数据的查询

  下图演示不对数据实施转换的 LINQ to Objects
查询操作。源包蕴3个字符串类别,查询输出也是3个字符串系列。 

金沙注册送58 105

  1数据源的门类参数决定限制变量的项目。

  二挑选的靶子的档次决定查询变量的档次。此处的 name 为三个字符串。由此,查询变量是1个 IEnumerable<字符串>。
 

  ③在 foreach 语句中循环访问查询变量。因为查询变量是3个字符串体系,所以迭代变量也是一个字符串。
 

 

  四.一 不转换源数据的查询

  下图演示不对数据实施转换的 LINQ to Objects
查询操作。源包括2个字符串系列,查询输出也是多个字符串类别。 

金沙注册送58 106

  (壹)数据源的品种参数决定限制变量的花色。

  (2)选拔的目的的种类决定查询变量的种类。此处的 name 为多少个字符串。由此,查询变量是贰个 IEnumerable<字符串>。
 

  (3)在 foreach 语句中循环访问查询变量。因为查询变量是三个字符串体系,所以迭代变量也是叁个字符串。
 

 

   
 不必在阐明并起始化变量时显式内定项目,您能够应用 var
修饰符来提醒编写翻译器预计并分配项目,注解为 var
的变量与显式钦定其项目标变量1样都以强类型。通过选择var,能够创建匿名类型,但它可用来其余部分变量。也足以行使隐式类型注明数组。

  4.贰 转换源数据的查询

  下图演示对数码进行简单转换的 LINQ to
SQL 查询操作。查询将三个 Customer 对象系列用作输入,并只选取结果中的 Name 属性。因为 Name 是贰个字符串,所以查询生成八个字符串连串作为出口。  

金沙注册送58 107

  一数据源的门类参数决定限制变量的项目。

  ②select 语句重回 Name 属性,而非完整的 Customer 对象。因为 Name 是二个字符串,所以 custNameQuery 的连串参数是 string,而非Customer。
 

  3因为 custNameQuery 是二个字符串系列,所以 foreach 循环的迭代变量也亟须是 string

 

  下图演示另一种转移。select 语句重返只捕获原始 Customer 对象的四个成员的匿名类型。

金沙注册送58 108

  1数据源的类型参数始终为查询中的范围变量的门类。

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

  3因为查询变量的品类是隐式的,所以 foreach 循环中的迭代变量也务必是隐式的。

 

  四.二 转换源数据的询问

  下图演示对数码进行简单转换的 LINQ to
SQL 查询操作。查询将一个 Customer 对象连串用作输入,并只采取结果中的 Name 属性。因为 Name 是2个字符串,所以查询生成二个字符串系列作为出口。  

金沙注册送58 109

  一数据源的档次参数决定限制变量的类别。

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

  3因为 custNameQuery 是3个字符串连串,所以 foreach 循环的迭代变量也不能不是 string

 

  下图演示另1种转移。select 语句重临只捕获原始 Customer 对象的四个分子的匿名类型。

金沙注册送58 110

  一数据源的花色参数始终为查询中的范围变量的档次。

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

  3因为查询变量的品种是隐式的,所以 foreach 循环中的迭代变量也务必是隐式的。

 

  四.二 转换源数据的查询

  下图演示对数码进行简单转换的 LINQ to
SQL 查询操作。查询将叁个 Customer 对象系列用作输入,并只选用结果中的 Name 属性。因为 Name 是1个字符串,所以查询生成3个字符串连串作为出口。  

金沙注册送58 111

  (壹)数据源的品类参数决定限制变量的类型。

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

  (三)因为 custNameQuery 是一个字符串系列,所以 foreach 循环的迭代变量也不能够不是 string

 

  下图演示另一种转移。select 语句重回只捕获原始 Customer 对象的七个分子的匿名类型。

金沙注册送58 112

  (一)数据源的品类参数始终为查询中的范围变量的类型。

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

  (叁)因为查询变量的连串是隐式的,所以 foreach 循环中的迭代变量也非得是隐式的。

 

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

  四.叁 让编写翻译器猜测类型音信

  您也足以选取主要字 var,可用来查询操作中的任何部分变量。不过,编写翻译器为查询操作中的各样变量提供强类型。  

金沙注册送58 113

 

  4.三 让编写翻译器估摸类型音信

  您也得以选择首要字 var,可用来查询操作中的任何部分变量。但是,编写翻译器为查询操作中的各类变量提供强类型。  

金沙注册送58 114

 

  4.三 让编写翻译器估计类型消息

  您也足以选拔让编译器为你执行总体育工作作。关键字 var 可用于查询操作中的任何部分变量。但是,编写翻译器为查询操作中的各样变量提供强类型。  

金沙注册送58 115

 

    • 对象和集合初步值设定项

5、LINQ 中的查询语法和办西班牙语法

  咱们编辑的 LINQ 查询语法,在编写翻译代码时,CLKuga会将查询语法转换为格局语法。这么些艺术调用标准查询运算符的名称类似 WhereSelectGroupByJoinMax和 Average,大家也是足以平素运用那一个办立陶宛(Lithuania)语法的。
 

  查询语法和章程语拉脱维亚语义相同,不过,许几人手发现查询语法更简明、更易于阅读。有些查询必须代表为格局调用。例如,必须运用形式调用表示检索成分的数额与钦定的口径的询问。还非得使用办法须求寻找成分的最大值在源种类的查询。System.Linq 命名空间中的标准查询运算符的参阅文书档案平日使用方马耳他语法。

 

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

  大家编辑的 LINQ 查询语法,在编写翻译代码时,CLTiggo会将查询语法转换为艺术语法。这几个主意调用标准查询运算符的称号类似 WhereSelectGroupByJoinMax和 Average,大家也是足以平素使用那些方朝鲜语法的。
 

  查询语法和格局语土耳其语义相同,可是,许多少人口发现查询语法更不难、更易于阅读。有些查询必须代表为格局调用。例如,必须使用方式调用表示检索成分的数码与钦点的口径的询问。还非得采取办法必要寻找成分的最大值在源序列的询问。System.Linq 命名空间中的标准查询运算符的参考文书档案日常使用方葡萄牙语法。

 

伍、LINQ 中的查询语法和情势语法

  在表示语言集成查询 (LINQ) 使用 LINQ
性查询语法,文档中的多数询问编写。可是,编写翻译代码时,必须将查询语法转换为艺术,那就必要.NET 公共语言运转时
(CL奥迪Q5)。那几个措施调用标准查询运算符的名号类似 WhereSelectGroupByJoinMax和 Average。能够调用这一个点子直接使用方马耳他语法而不是询问语法。
 

  查询语法和方波兰语塞尔维亚共和国语义相同,但是,许四人士发现查询语法更简短、更易于阅读。某个查询必须代表为格局调用。例如,必须选拔办法调用表示检索元素的多寡与钦命的规范的询问。还非得运用形式须要寻找成分的最大值在源类别的询问。System.Linq 命名空间中的标准查询运算符的参照文书档案平日选用方式语法。

 

   
 通过对象和集合初步值设定项,起首化对象时无需为指标显式调用构造函数。开端值设定项普通用在将源数据投影到新数据类型的查询表明式中。假定三个类名称为Customer,具有公共 Name 和 Phone
属性,能够按下列代码中所示使用对象开始值设定项:

  五.1 标准查询运算符扩张方法

金沙注册送58 116金沙注册送58 117

 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         }

上边的示范演示简单的询问表明式和编写制定为遵照方法的询问的语义上等效的查询。

金沙注册送58 118

  两个示范的出口是壹致的。您能够看到两种样式的查询变量的体系是平等的:IEnumerable<T>。
 

  若要精通基于方法的询问,让大家尤其地分析它。注意,在表达式的右手,where 子句未来代表为对 numbers 对象的实例方法,在你再度调用该对象时其品种为 IEnumerable<int>。假使您熟识泛型 IEnumerable<T> 接口,那么你就会询问,它不抱有 Where 方法。不过,如若您在
Visual Studio IDE 中调用 英特尔liSense
完结列表,那么你不只将看到 Where 方法,而且还会看到数不胜数别样艺术,如 SelectSelectManyJoin 和Orderby。上面是独具正规查询运算符。 

金沙注册送58 119

  纵然看起来 IEnumerable<T> 就好像已被再次定义以囊括那些附加措施,但事实上并非如此。这个专业查询运算符都是当做“扩大方法”达成的。

 

  伍.一 标准查询运算符扩展方法

金沙注册送58 120金沙注册送58 121

 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         }

上边包车型客车以身作则演示简单的询问表达式和编辑为依据方法的查询的语义上等效的询问。

金沙注册送58 122

  四个示范的输出是如出壹辙的。您能够看出两种情势的询问变量的项目是相同的:IEnumerable<T>。
 

  若要明白基于方法的查询,让大家更为地解析它。注意,在表明式的右手,where 子句以后表示为对 numbers 对象的实例方法,在您再也调用该对象时其种类为 IEnumerable<int>。假如您熟谙泛型 IEnumerable<T> 接口,那么您就会询问,它不拥有 Where 方法。但是,假诺您在
Visual Studio IDE 中调用 速龙liSense
完结列表,那么你不仅将见到 Where 方法,而且还会看出不少任何方式,如 SelectSelectManyJoin 和Orderby。上边是全数标准查询运算符。 

金沙注册送58 123

  即便看起来 IEnumerable<T> 就像是已被重新定义以囊括这么些附加措施,但其实并非如此。这一个标准查询运算符都以作为“扩张方法”完成的。

 

  5.一 标准查询运算符扩充方法

金沙注册送58 124 1 static
void Main(string[] args) 2 { 3 var nums = new int[4] { 一, 二, 三, 4 };
四 伍 //创造查询表明式 6 var qureyNums = from n in nums 7 where n % 贰 == 0
8 orderby n descending 九 select n; 10 1①Console.WriteLine(“qureyNums:”); 1二 foreach (var n in qureyNums) 1三 { 14
Console.WriteLine(n); 一5 } 1六 1七 //运用情势实行查询 1八 var queryNums二 =
nums.Where(n => n % 二 == 0).OrderByDescending(n => n); 1九 20
Console.WriteLine(“qureyNums2:”); 贰一 foreach (var n in queryNums贰) 2二 {
二三 Console.WriteLine(n); 2四 } 25 26 Console.Read(); 2柒 } 下边包车型客车以身作则演示简单的询问表明式和编制为基于方法的查询的语义上等效的询问。

金沙注册送58 125

  八个示范的出口是千篇一律的。您可以看看二种样式的查询变量的连串是均等的:IEnumerable<T>。
 

  若要精晓基于方法的查询,让大家更为地解析它。注意,在表明式的右手,where 子句以往表示为对 numbers 对象的实例方法,在您再也调用该对象时其类别为 IEnumerable<int>。假设您纯熟泛型 IEnumerable<T> 接口,那么你就会询问,它不富有 Where 方法。可是,假设你在
Visual Studio IDE 中调用 速龙liSense
实现列表,那么您不只将见到 Where 方法,而且还晤面到不少任何方式,如 SelectSelectManyJoin 和Orderby。上面是装有正式查询运算符。 

金沙注册送58 126

  固然看起来 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 % 二 == 0) 是作为内联参数。Where 方法:Where(num
=> num % 二 == 0) 此内联表达式称为 lambda
表明式。将代码编写为匿名格局或泛型委托或表明式树是一种便利的法子,否则编写起来就要麻烦得多。=> 是
lambda 运算符,可读为“goes
to”。运算符左边的 num 是输入变量,与查询表明式中的 num 相对应。编写翻译器可推断 num 的门类,因为它领会 numbers 是泛型 IEnumerable<T> 类型。lambda
表明式与查询语法中的表明式或别的其余 C#
表达式或语句中的表明式相同;它可以包括方法调用和别的复杂逻辑。“返回值”就是表明式结果。
 

 

  5.2 Lambda 表达式

  在前边的示范中,文告该标准发挥式 (num % 二 == 0)
是作为内联参数。Where 方法:Where(num => num % ② == 0)
此内联表明式称为 lambda
表明式。将代码编写为匿名方式或泛型委托或表明式树是壹种便利的法门,不然编写起来就要麻烦得多。=> 是
lambda 运算符,可读为“goes
to”。运算符左边的 num 是输入变量,与查询表达式中的 num 相对应。编写翻译器可估量 num 的门类,因为它精通 numbers 是泛型 IEnumerable<T> 类型。lambda
表明式与查询语法中的表明式或别的其余 C#
表明式或语句中的表明式相同;它能够包罗方法调用和其它复杂逻辑。“再次来到值”正是表明式结果。
 

 

    • 匿名类型

  伍.3 查询的组合性

  在上头的代码示例中,请留心 OrderBy 方法是由此在对 Where 的调用中央银行使点运算符来调用的。Where 生成筛选种类,然后 Orderby 通过对该系列排序来对它举行操作。因为查询会重临 IEnumerable,所以您可由此将艺术调用链接在壹块,在艺术语法上校这个查询组合起来。那便是在您通过利用查询语法编写查询时编写翻译器在后台所实施的操作。并且由于查询变量不存储查询的结果,因而你可以每日修改它或将它用作新查询的根基,固然在履行它后。

 

  5.3 查询的组合性

  在上头的代码示例中,请留心 OrderBy 方法是经过在对 Where 的调用中选取点运算符来调用的。Where 生成筛选种类,然后 Orderby 通过对该种类排序来对它举办操作。因为查询会重回 IEnumerable,所以你可透过将艺术调用链接在一齐,在点子语法中校这个查询组合起来。那就是在你通过运用查询语法编写查询时编写翻译器在后台所推行的操作。并且由于查询变量不存款和储蓄查询的结果,由此你可以每1天修改它或将它用作新查询的底蕴,就算在实践它后。

 

  伍.三 查询的组合性

  在下面的代码示例中,请小心 OrderBy 方法是通过在对 Where 的调用中利用点运算符来调用的。Where 生成筛选类别,然后 Orderby 通过对该连串排序来对它实行操作。因为查询会重返 IEnumerable,所以你可通过将艺术调用链接在协同,在章程语法少将这个查询组合起来。那正是在你通过采纳查询语法编写查询时编写翻译器在后台所举行的操作。并且由于查询变量不存款和储蓄查询的结果,由此你能够随时修改它或将它用作新查询的底子,固然在推行它后。

 

正文首联:

 

–待整理形成后再一次揭橥到首页–

  

] 初步接纳 LINQ, 初步运用 LINQ
在此以前曾刊登过3篇关于 LINQ 的小说: 进阶:《LINQ 标准查询操作概述》
(强烈推荐) 技巧:《Linq…

   
 匿名类型由编写翻译器营造,且项目名称只可用以编写翻译器。匿名类型提供了壹种在查询结果中近来分组一组属性的有益方法,无需定义单独的命名类型。使用新的表明式和对象开端值设定项起始化匿名类型。

传送门

  入门:《走进 LINQ
的世界》

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

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

 

 


本文首联:

【参考】

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

 

 

  

传送门

  入门:《走进 LINQ
的世界》

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

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

 

 


正文首联:

【参考】

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

 

 

  

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

   
 增添方法是一种可与品类涉及的静态方法,因而得以像实例方法那样对项目调用它。实际上,此功用使你能够将新格局“添加”到现有项目,而不会实际修改它们。标准查询运算符是一组扩大方法,它们为兑现
IEnumerable<T> 的其余类型提供 LINQ 查询功效。

    • Lambda 表达式

     拉姆da
表明式是一种内联函数,该函数使用 =>
运算符将输入参数与函数体分离,并且能够在编写翻译时转换为委托或发表式树。在
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 查询全部3大优势:

    • 它们更显明、更易读,特别在筛选多少个原则时。
    • 它们利用最少的应用程序代码提供强劲的筛选、排序和分组成效。
    • 毋庸修改或只需做非常的小的改动即可将它们移植到别的数据源。

相关文章

网站地图xml地图