当前位置：文档库 › LINQ

LINQ

LINQ 介绍

语言集成查询(LINQ) 是Visual Studio 2008 和.NET Framework 3.5 版中引入的一项创新功能，它在对象领域和数据领域之间架起了一座桥梁。传统上，针对数据的查询都是以简单的字符串表示，而没有编译时类型检查或IntelliSense 支持。此外，您还必须针对以下各种数据源学习一种不同的查询语言：SQL 数据库、XML 文档、各种Web 服务等等。LINQ 使查询成为C# 和Visual Basic 中的一流语言构造。您可以使用语言关键字和熟悉的运算符针对强类型化对象集合编写查询。下图显示了一个用C# 语言编写的、不完整的LINQ 查询，该查询针对SQL Server 数据库，并具有完全类型检查和IntelliSense 支持。

在Visual Studio 中，可以用Visual Basic 或C# 为以下数据源编写LINQ 查询：SQL Server 数据库、XML 文档、https://www.wendangku.net/doc/16392581.html, 数据集，以及支持IEnumerable 或泛型IEnumerable(Of T) 接口的任意对象集合。此外，还计划了对https://www.wendangku.net/doc/16392581.html, Entity Framework 的LINQ 支持，并且第三方为许多Web 服务和其他数据库实现编写了LINQ 提供程序。

LINQ 查询既可在新项目中使用，也可在现有项目中与非LINQ 查询一起使用。唯一的要求是项目应面向.NET Framework 3.5 或更高版本。基本LINQ 查询操作

本主题简要介绍LINQ 查询表达式，以及您在查询中执行的一些典型类型的操作。下面各主题中提供了更详细的信息：

LINQ 查询表达式（C# 编程指南）

标准查询运算符概述

注意

如果您已熟悉查询语言（如SQL 或XQuery），则可以跳过本主题的大部分内容。阅读下一节中的“from 子句”来了解LINQ 查询表达式中的子句的顺序。

获取数据源

--------------------------------------------------------------------------------

在LINQ 查询中，第一步是指定数据源。像在大多数编程语言中一样，在C# 中，必须先声明变量，才能使用它。在LINQ 查询中，最先使用from 子句的目的是引入数据源(customers) 和范围变量(cust)。

C#复制

//queryAllCustomers is an IEnumerable

var queryAllCustomers = from cust in customers

select cust;

范围变量类似于foreach 循环中的迭代变量，但在查询表达式中，实际上不发生迭代。执行查询时，范围变量将用作对customers 中的每个后续元素的引用。因为编译器可以推断cust 的类型，所以您不必显式指定此类型。其他范围变量可由let 子句引入。有关更多信息，请参见let 子

句（C# 参考）。

注意

对于非泛型数据源（如ArrayList），必须显式类型化范围变量。有关更多信息，请参见如何：使用LINQ 查询ArrayList和from 子句（C# 参考）。筛选

--------------------------------------------------------------------------------

也许最常用的查询操作是应用布尔表达式形式的筛选器。此筛选器使查询只返回那些表达式结果为true 的元素。使用where 子句生成结果。实际上，筛选器指定从源序列中排除哪些元素。在下面的示例中，只返回那些地址位于伦敦的customers。

C#复制

var queryLondonCustomers = from cust in customers

where cust.City == "London"

select cust;

您可以使用熟悉的C# 逻辑AND 和OR 运算符来根据需要在where 子句中应用任意数量的筛选表达式。例如，若要只返回位于“伦敦”AND 姓名为“Devon”的客户，您应编写下面的代码：

C#复制

where cust.City=="London" && https://www.wendangku.net/doc/16392581.html, == "Devon"

若要返回位于伦敦或巴黎的客户，您应编写下面的代码：

C#复制

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

有关更多信息，请参见where 子句（C# 参考）。

Ordering

--------------------------------------------------------------------------------

通常可以很方便地将返回的数据进行排序。orderby 子句将使返回的序列中的元素按照被排序的类型的默认比较器进行排序。例如，下面的查询可以扩展为按Name 属性对结果进行排序。因为Name 是一个字符串，所以默认比较器执行从 A 到Z 的字母排序。

C#复制

var queryLondonCustomers3 =

from cust in customers

where cust.City == "London"

orderby https://www.wendangku.net/doc/16392581.html, ascending

select cust;

若要按相反顺序（从Z 到A）对结果进行排序，请使用order by…descending 子句。

有关更多信息，请参见orderby 子句（C# 参考）。

分组

--------------------------------------------------------------------------------

使用group 子句，您可以按指定的键分组结果。例如，您可以指定结果应按City 分组，以便位于伦敦或巴黎的所有客户位于各自组中。在本例中，cust.City 是键。

注意

在下面的示例中，类型是显式的以更好地说明概念。您也可以对custQuery、group 和customer 使用隐式类型以让编译器确定准确的类型。

C#复制

// queryCustomersByCity is an IEnumerable>

var queryCustomersByCity =

from cust in customers

group cust by cust.City;

// customerGroup is an IGrouping

foreach (var customerGroup in queryCustomersByCity)

Console.WriteLine(customerGroup.Key);

foreach (Customer customer in customerGroup)

{

Console.WriteLine(" {0}", https://www.wendangku.net/doc/16392581.html,);

}

在使用group 子句结束查询时，结果采用列表的列表形式。列表中的每个元素是一个具有Key 成员及根据该键分组的元素列表的对象。在循环访问生成组序列的查询时，您必须使用嵌套的foreach 循环。外部循环用于循环访问每个组，内部循环用于循环访问每个组的成员。

如果您必须引用组操作的结果，可以使用into 关键字来创建可进一步查询的标识符。下面的查询只返回那些包含两个以上的客户的组：

C#复制

// custQuery is an IEnumerable>

var custQuery =

from cust in customers

group cust by cust.City into custGroup

where custGroup.Count() > 2

orderby custGroup.Key

select custGroup;

有关更多信息，请参见group 子句（C# 参考）。

联接

--------------------------------------------------------------------------------

联接运算创建数据源中没有显式建模的序列之间的关联。例如，您可以执行联接来查找位于同一地点的所有客户和经销商。在LINQ 中，join 子句始终针对对象集合而非直接针对数据库表运行。

C#复制

var innerJoinQuery =

from cust in customers

join dist in distributors on cust.City equals dist.City

select new { CustomerName = https://www.wendangku.net/doc/16392581.html,, DistributorName = https://www.wendangku.net/doc/16392581.html, };

在LINQ 中，您不必像在SQL 中那样频繁使用join，因为LINQ 中的外键在对象模型中表示为包含项集合的属性。例如，Customer 对象包含Order 对象的集合。不必执行联接，只需使用点表示法访问订单：

使用LINQ 进行数据转换(C#)

语言集成查询 (LINQ) 不仅可用于检索数据，

而且还是一个功能强大的数据转换工具。

通过使用 LINQ 查询，您可以将源序列用作输入，并采用多种方式修改它以创建新输出序列。

您可以通过排序和分组来修改序列本身，而不必修改元素本身。但是，LINQ 查询的最强大功能可能在于它能够创建新类型。这一功能在

select

子句中实现。

例如，可以执行下列任务：

将多个输入序列合并到具有新类型的单个输出序列中。

创建其元素只包含源序列中的各个元素的一个或几个属性的输出序列。

创建其元素包含对源数据执行的操作结果的输出序列。

创建不同格式的输出序列。

例如，您可以将 SQL 行或文本文件的数据转换为 XML。

这只是几个示例。

当然，可以采用多种方式将这些转换组合在同一查询中。

另外，一个查询的输出序列可用作新查询的输入序列。

将多个输入联接到一个输出序列

可以使用 LINQ 查询来创建包含多个输入序列的元素的输出序列。

下面的示例演示如何组合两个内存中的数据结构，但组合来自 XML 或 SQL 或数据集源的数据时可应用相同的原则。假定下面两种类类型：

class Student

{

public

string First { get; set; }

public

string Last {get; set;}

public

int ID { get; set; }

public

string Street { get; set; }

public

string City { get; set; }

public List Scores;

}

class Teacher

{

public

string First { get; set; }

public

string Last { get; set; }

public

int ID { get; set; }

public

string City { get; set; }

}

下面的示例演示该查询：

class DataTransformations

{

static

void Main()

{

// Create the first data source.

List students = new List()

{

new Student {First="Svetlana",

Last="Omelchenko",

ID=111,

Street="123 Main Street",

City="Seattle",

Scores= new List {97, 92, 81, 60}},

new Student {First="Claire",

Last="O’Donnell",

ID=112,

Street="124 Main Street",

City="Redmond",

Scores= new List {75, 84, 91, 39}},

new Student {First="Sven",

Last="Mortensen",

ID=113,

Street="125 Main Street",

City="Lake City",

Scores= new List {88, 94, 65, 91}},

};

// Create the second data source.

List teachers = new List()

{

new Teacher {First="Ann", Last="Beebe", ID=945, City = "Seattle"},

new Teacher {First="Alex", Last="Robinson", ID=956, City = "Redmond"}, new Teacher {First="Michiyo", Last="Sato", ID=972, City = "Tacoma"}

};

// Create the query.

var peopleInSeattle = (from student in students

where student.City == "Seattle"

select https://www.wendangku.net/doc/16392581.html,st)

.Concat(from teacher in teachers

where teacher.City == "Seattle"

select https://www.wendangku.net/doc/16392581.html,st);

Console.WriteLine("The following students and teachers live in Seattle:"); // Execute the query.

foreach (var person in peopleInSeattle)

{

Console.WriteLine(person);

}

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

/* Output:

The following students and teachers live in Seattle:

Omelchenko

Beebe

选择各个源元素的子集

选择源序列中的各个元素的子集有两种主要方法：

若要只选择源元素的一个成员，请使用点运算。

在下面的示例中，假定 Customer 对象包含几个公共属性，其中包括名为 City 的字符串。

在执行此查询时，此查询将生成字符串输出序列。

other

var query = from cust in Customers

select cust.City;

若要创建包含源元素的多个属性的元素，可以使用具有命名对象或匿名类型的对象初始值设定项。

下面的示例演示如何使用匿名类型来封装各个 Customer 元素的两个属性：

other

var query = from cust in Customer

select new {Name = https://www.wendangku.net/doc/16392581.html,, City = cust.City};

将内存中的对象转换为 XML

通过 LINQ 查询，可以轻松地在内存中的数据结构、SQL 数据库、https://www.wendangku.net/doc/16392581.html, 数据集和 XML 流或文档之间转换数据。

下面的示例将内存中的数据结构中的对象转换为 XML 元素。

class XMLTransform

{

static

void Main()

{

// Create the data source by using a collection initializer.

List students = new List()

{

new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores = new List{97, 92, 81, 60}}, new Student {First="Claire", Last="O’Donnell", ID=112, Scores = new List{75, 84, 91, 39}}, new Student {First="Sven", Last="Mortensen", ID=113, Scores = new List{88, 94, 65, 91}},

};

// Create the query.

var studentsToXML = new XElement("Root",

from student in students

let x = String.Format("{0},{1},{2},{3}", student.Scores[0],

student.Scores[1], student.Scores[2], student.Scores[3])

select

new XElement("student",

new XElement("First", student.First),

new XElement("Last", https://www.wendangku.net/doc/16392581.html,st),

new XElement("Scores", x)

) // end "student"

); // end "Root"

// Execute the query.

Console.WriteLine(studentsToXML);

// Keep the console open in debug mode.

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

此代码生成下面的 XML 输出：

other

< Root>

Svetlana

Omelchenko

97,92,81,60

Claire

O'Donnell

75,84,91,39

Sven

Mortensen

88,94,65,91

对源元素执行操作

输出序列可能不包含源序列的任何元素或元素属性。

输出可能是通过将源元素用作输入参数计算出的值的序列。

在执行下面这个简单查询时，此查询会输出一个字符串序列，该序列值表示根据 double 类型的元素的源序列进行的计算。注意

如果查询将转换为某个其他域，则不支持在查询表达式中调用方法。

例如，不能在 LINQ to SQL 中调用一般 C# 方法，因为 SQL Server 没有该方法的上下文。但是，可以将存储过程映射到方法，然后调用方法。

class FormatQuery

{

static

void Main()

{

// Data source.

double[] radii = { 1, 2, 3 };

// Query.

IEnumerable query =

from rad in radii

select String.Format("Area = {0}", (rad * rad) * 3.14);

// Query execution.

foreach (string s in query)

Console.WriteLine(s);

// Keep the console open in debug mode.

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}

/* Output:

Area = 3.14

Area = 12.56

Area = 28.26

LINQ 和泛型类型(C#)

LINQ 查询基于泛型类型，在 .NET Framework 的 2.0 版中引入了泛型类型。

您无需深入了解泛型即可开始编写查询。

但是，您可能需要了解两个基本概念：

当您创建泛型集合类（如

List(Of T)）的实例时，您将“T”替换为列表将包含的对象的类型。

例如，字符串列表表示为 List，Customer 对象列表表示为 List。

泛型列表是强类型的，且提供了比将其元素存储为

Object

的集合更多的好处。

如果您尝试将 Customer 添加到 List，则会在编译时出现一条错误。

泛型集合易于使用的原因是您不必执行运行时类型强制转换。

IEnumerable(Of T)

是一个接口，通过该接口，可以使用 foreach 语句来枚举泛型集合类。

泛型集合类支持

IEnumerable(Of T)，就像非泛型集合类（如

ArrayList）支持

IEnumerable。

LINQ 查询中的 IEnumerable 变量

LINQ 查询变量类型化为

IEnumerable(Of T)

或派生类型，如

IQueryable(Of T)。

当您看到类型化为 IEnumerable 的查询变量时，这只意味着在执行该查询时，该查询将生成包含零个或多个Customer 对象的序列。

IEnumerable customerQuery =

from cust in customers

where cust.City == "London"

select cust;

foreach (Customer customer in customerQuery)

{

Console.WriteLine(https://www.wendangku.net/doc/16392581.html,stName + ", " + customer.FirstName);

}

让编译器处理泛型类型声明

如果您愿意，可以使用

var

关键字来避免使用泛型语法。

var 关键字指示编译器通过查看在 from 子句中指定的数据源来推断查询变量的类型。

下面的示例生成与上一个示例相同的编译代码：

var customerQuery2 =

from cust in customers

where cust.City == "London"

select cust;

foreach(var customer in customerQuery2)

{

Console.WriteLine(https://www.wendangku.net/doc/16392581.html,stName + ", " + customer.FirstName);

}

LINQ 查询语法与方法语法(C#)

通过使用 C# 3.0 中引入的声明性查询语法，介绍性 LINQ 文档中的多数查询都被编写为查询表达式。

但是，.NET 公共语言运行时 (CLR) 本身并不具有查询语法的概念。

因此，在编译时，查询表达式会转换为 CLR 确实了解的内容：方法调用。

这些方法称为“标准查询运算符”，它们具有如下名称：Where、Select、GroupBy、Join、Max、Average

等。可以通过使用方法语法而非查询语法来直接调用这些方法。

通常我们建议使用查询语法，因为它通常更简单、更易读；但是方法语法和查询语法之间并无语义上的区别。

此外，一些查询（如检索匹配指定条件的元素数的那些查询或检索具有源序列中的最大值的元素的查询）只能表示为方法调用。System.Linq

命名空间中的标准查询运算符的参考文档通常使用方法语法。

因此，即使在开始编写 LINQ 查询时，熟悉如何在查询和查询表达式本身中使用方法语法也非常有用。

标准查询运算符扩展方法

下面的示例演示简单的查询表达式和编写为基于方法的查询的语义上等效的查询。

1.C#

2.class QueryVMethodSyntax

3.{

4.static

5.void Main()

6.{

7.int[] numbers = { 5, 10, 8, 3, 6, 12};

8.//Query syntax:

9.IEnumerable numQuery1 =

10.from num in numbers

11.where num % 2 == 0

12.orderby num

13.select num;

14.//Method syntax:

15.IEnumerable numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n => n);

16.foreach (int i in numQuery1)

17.{

18.Console.Write(i + " ");

19.}

20.Console.WriteLine(System.Environment.NewLine);

21.foreach (int i in numQuery2)

22.{

23.Console.Write(i + " ");

24.}

25.// Keep the console open in debug mode.

26.Console.WriteLine(System.Environment.NewLine);

27.Console.WriteLine("Press any key to exit");

28.Console.ReadKey();

29.}

30.}

31./*

32.Output:

33. 6 8 10 12

34. 6 8 10 12

35.*/

复制代码

两个示例的输出是相同的。

您可以看到两种形式的查询变量的类型是相同的：IEnumerable(Of T)。

若要了解基于方法的查询，让我们进一步地分析它。

注意，在表达式的右侧，where 子句现在表示为对 numbers 对象的实例方法，在您重新调用该对象时其类型为

IEnumerable。

如果您熟悉泛型

IEnumerable(Of T)

接口，那么您就会了解，它不具有Where

方法。

但是，如果您在 Visual Studio IDE 中调用 IntelliSense 完成列表，那么您不仅将看到Where

方法，而且还会看到许多其他方法，如Select、SelectMany、Join

和Orderby。

下面是所有标准查询运算符。

尽管看起来

IEnumerable(Of T)

似乎已被重新定义以包括这些附加方法，但事实上并非如此。

这些标准查询运算符作为一种新的方法（称为“扩展方法”）实现。

扩展方法可“扩展”现有类型；可如对类型的实例方法一样调用。

标准查询运算符可扩展

IEnumerable(Of T)，这就是您可以编写 numbers.Where(...) 的原因。

若要开始使用 LINQ，您实际需要了解的有关扩展方法的所有内容是，如何通过使用正确的 using 指令将它们置于您的应用程序中的范围内。

您可以在如何：创建 LINQ 项目中进一步了解相关信息。

从应用程序的角度来看，扩展方法和正常的实例方法是相同的。

Lambda 表达式

请注意，在上面的示例中，条件表达式 (num % 2 == 0) 是作为内联参数传递到Where

方法的：Where(num => num % 2 == 0). 。此内联表达式称为 lambda 表达式。

将代码编写为匿名方法或泛型委托或表达式树是一种便捷的方法，否则编写起来就要麻烦得多。

在 C# 中，=> 是 lambda 运算符，可读为“goes to”。

运算符左侧的 num 是输入变量，与查询表达式中的 num 相对应。

编译器可推断 num 的类型，因为它了解 numbers 是泛型

IEnumerable(Of T)

类型。

lambda 表达式与查询语法中的表达式或任何其他 C# 表达式或语句中的表达式相同；它可以包括方法调用和其他复杂逻辑。“返回值”就是表达式结果。

若要开始使用 LINQ，您不必大量使用 lambda。

但是，特定查询只可使用方法语法表示，其中一些查询需要使用 lambda 表达式。

进一步熟悉 lambda 后，您会发现，在 LINQ 工具栏中，它们是强大且灵活的工具。

查询的组合性

在上面的代码示例中，请注意OrderBy

方法是通过在对Where

的调用中使用点运算符来调用的。

Where

生成筛选序列，然后Orderby

通过对该序列排序来对它进行操作。

因为查询会返回IEnumerable，所以您可通过将方法调用链接在一起，在方法语法中将这些查询组合起来。这就是在您通过使用查询语法编写查询时编译器在后台所执行的操作。

并且由于查询变量不存储查询的结果，因此您可以随时修改它或将它用作新查询的基础，即使在执行它后。

微软LINQ中文教程

。LINQ中文教程 LINQ初体验之LINQ to Object (1) 一步一步学Linq to sql（一）：预备知识 (4) 一步一步学Linq to sql（二）：DataContext与实体 (9) 一步一步学Linq to sql（三）：增删改 (15) 一步一步学Linq to sql（四）：查询句法 (21) 一步一步学Linq to sql（五）：存储过程 (35) 一步一步学Linq to sql（六）：探究特性 (46) 一步一步学Linq to sql（七）：并发与事务 (53) 一步一步学Linq to sql（八）：继承与关系 (60) 一步一步学Linq to sql（九）：其它补充 (69) 一步一步学Linq to sql（十）：分层构架的例子 (73) Linq To Xml学习 (80) Linq To Xml学习－1. 概述 (80) Linq To Xml学习－2 编程概述 (82) C# 2008 学习笔记- LINQ to XML (87) 一、命名空间 (87) 二、编程方式创建XML文档 (88) 三、使用LINQ 查询创建XML文档 (89) 四、加载和解析XML内容 (90) 六、遍历内存中的XML文档 (90) 七、修改XML文档 (92) 使用linq to xml 快速创建自己的Rss (93) LINQ初体验之LINQ to Object VS2008的发布，最激动人心的不过是LINQ的诞生。

Wh at‘s LINQ? Language Integrated Query 是也。说得再明白一些，这是编程语言的一种新特性，能够将数据查询语句集成到编程语言中。目前，LINQ 支持的语言有C# 和VB。为啥会有LINQ，主要还是因为现在的数据格式越来越多，数据库、XML、数组、哈希表……每一种都有自己操作数据的方式，学起来费事费力。于是，就有了LINQ诞生的理由——以一种统一的方式操作各种数据源，减少数据访问的复杂性。 LINQ带来很多开发上的便利。首先，他可以利用Visual Studio这个强大的IDE(这话决不是吹，Visual Studio绝对是最好用的开发工具之一)，至少用Visual Studio来写SQL语句，可以有智能感知了，比起从前用查询分析器写存储过程的感觉好多了!其次，它可以把数据当成一个对象来操作，即Data == Object? 的问题。 LINQ目前可以对XML, Object, SQL做数据访问，今后还会有LINQ to Entity 的功能。说来惭愧，我也是刚刚才接触LINQ，先从最简单的开始吧，做一个LINQ to Object的例子，实现一个对数组的操作。这个例子套用了今年TechED中海洋兄讲的例子，在此声明。在这个例子中，我会先通过GetMethods的方法，拿到string的所有方法，接下来，就看LINQ的厉害了，这里是选出所有非静态的方法签名。 MethodInfo[] methods = typeof(string).GetMethods(); var result = from m in methods where m.IsStatic != true select https://www.wendangku.net/doc/16392581.html,; foreach (var r in result) { Console.WriteLine(r.ToString()); } Console.ReadLine(); 例子虽然简单，确能从中看出LINQ的一些端倪。首先，var是什么东东? 看起来，有点像javascript里面的弱类型的变量声明。但是，C#是强类型的，尽管你用var来声明，编译器还是可以根据上下文推倒出它当前的类型。比如这个例子里面，result就是IEnumerable 类型的。在这里面，写IEnumerable和写var是一样效果的，显然，var会简单得多。你不用考虑数据操作的返回值是什么类型，还能享受强类型声明带来的方便实惠……

C#读取_SQL_Server_数据库表的例子

C#读取 SQL Server 数据库表的例子 using System; using System.Data; using System.Data.SqlClient; using System.Collections.Generic; using System.Linq; using System.Text; namespace A0160_SQL_Server.Sample { ///

/// 用于读取 SQL Server 数据库的例子. /// /// 注意：这个例子所使用的表和数据，请参考项目下的 Schema.sql 文件。 /// ///

class ReadSqlServerData { ///

/// SQL Server 的数据库连接字符串. ///

private const String connString = @"Data Source=localhost\SQLEXPRESS;Initial Catalog=Sample;Integrated Security=True"; ///

/// 用于查询的 SQL 语句. ///

private const String SQL = @" SELECT TOP 3 ROW_NUMBER() OVER (ORDER BY SUM(SALE_MONEY) DESC) AS NO, SALE_DATE, SUM(SALE_MONEY) AS SUM_MONEY FROM SALE_REPORT GROUP BY SALE_DATE

linq查询数据库实例

实例28、创建LINQ TO sql的步骤： 1）建立windows 窗体应用项目文件 2）选择'项目\添加新项'菜单，在类别中选择'常用项'，在'模板'视图中选择'LINQ to sql '类，系统自动添加用户命名的LINQ to SQL 文件（dataclasses1.dbml） 3）选择'视图\服务器资源管理器'菜单，拖动数据链接的表或者视图节点到LINQ to SQL 的对象关系设计器设计视图的左边的一个窗格，系统将自动添加数据表。4）选择'生成\生成myform'菜单，然后选择'数据\显示数据源'菜单，弹出'数据源'窗口，单击'添加新数据源'超级链接，弹出'数据源配置向导'对话框。 5）在'数据源配置向导（选择数据源类型）'对话框的'应用程序从哪里获取数据？'列表视图中选择'对象'，再单击'下一步'，弹出'数据源配置向导（选择希望绑定到的对象）'对话框，在对话框的'对象位于哪个程序集中？（如果没有出现，请取消该向导，然后重现生成包含对象的项目）'的树视图中选择数据表节点（比如gsyproduct表），再单击'下一步'，弹出'数据源配置向导（添加对象数据源）'对话框，在对话框中单击'完成'按钮，则会在'数据源'窗口中显示数选择的数据表（比如gsyproduct ）的字段信息。 6）在'数据源'窗口中拖动'gsyproduct'节点到应用程序窗体'Form1.vb(设计)'视图，系统将自动添加相关的数据控件gsyproductbindingsource、gsyproductbindingnavigator、gsyproductdatagridview等。 7）使用鼠标双击'应用程序窗体Form1.vb(设计)'视图，系统将自动添加代码框架，在load事件处理代码框架中添加如下实现代码： public class form1 private MyDataContext as New Dataclasses1DataContext() '设置控件数据源 private sub Form1_load(ByVal sender as System.Object, ByVal e as System.EventArgs ) Handles MyBase.Load Me.gsyproductbindingsource.DataSource=MyDataContext.gsyproduct End Sub End Class

第8章--使用LINQ进行数据访问教程文件

第8章--使用L I N Q 进行数据访问

第8章使用LINQ进行数据访问一、选择题 1．LINQ查询表达式中必须包含（）子句。 A．from B．where C．orderby D．groupby 2．在LINQ查询表达式中，（）子句用于指定筛选元素的逻辑条件。 A．from B．where C．orderby D．select 3．LINQ查询表达式必须以（）子句结束。 A．where B．orderby C．groupby D．select或group 4．orderby子句降序排序时使用（）关键字。 A．ascending B．descending C．ASC D．DESC 5．使用LINQ操作SQL Server时，调用（）方法将最终操作结果更新到数据库中。A．InsertOnSubmit B．DeleteOnSubmit C．DeleteAllOnSubmit D．SubmitChanges 6．LINQ查询表达式中使用（）子句对查询结果进行分组。 A．from B．where C．orderby D．groupby 7．使用一个Lambda表达式从字符串数组s中查找包括“C#”的元素，则正确的语句是（）。A．Array.Find(strLists, s => (s.IndexOf("C#") >= 0)) B．Array.FindAll(strLists, s => (s.IndexOf("C#") >= 0)) C．Array.Find (strLists, s => (https://www.wendangku.net/doc/16392581.html,stIndexOf("C#") <= 0)) D．Array.FindAll(strLists, s => (https://www.wendangku.net/doc/16392581.html,stIndexOf("C#")<= 0)) 8．LINQ查询表达式中使用（）子句可以设置两个数据源之间的关联关系。 A．from B．groupby C．into D．join 9．下面代码实现的是（）操作。 var innerJoinQuery = from main in tb_sell_main join detailed in tb_sell_detailed on main.billcode equals detailed.billcode select new { 商品编号= detailed.tradecode, 商品全称= detailed.fullname,

LINQ入门教程

跟我学LINQ TO SQL ●LINQ是Language Integrated Query的简称，它是集成在.NET编程语言中的一种特性。已成为编程语言的一个组成部分，在编写程序时可以得到很好的编译时语法检查，丰富的元数据，智能感知、静态类型等强类型语言的好处。并且它同时还使得查询可以方便地对内存中的信息进行查询而不仅仅只是外部数据源。 ●LINQ定义了一组标准查询操作符用于在所有基于.NET平台的编程语言中更加直接地声明跨越、过滤和投射操作的统一方式，标准查询操作符允许查询作用于所有基于IEnumerable接口的源，并且它还允许适合于目标域或技术的第三方特定域操作符来扩大标准查询操作符集，更重要的是，第三方操作符可以用它们自己的提供附加服务的实现来自由地替换标准查询操作符，根据LINQ模式的习俗，这些查询喜欢采用与标准查询操作符相同的语言集成和工具支持。 ●LINQ架构

●相关命名空间一.LINQ简介 ●LINQ包括五个部分：LINQ to Objects、LINQ to DataSets、LINQ to SQL、LINQ to Entities、LINQ to XML。 ●LINQ to SQL全称基于关系数据的.NET语言集成查询，用于以对象形式管理关系数据，并提供了丰富的查询功能。其建立于公共语言类型系统中的基于SQL的模式定义的集成之上，当保持关系型模型表达能力和对底层存储的直接查询评测的性能时，这个集成在关系型数据之上提供强类型。 ●LINQ to XML在System.Xml.LINQ命名空间下实现对XML的操作。采用高效、易用、内存中的XML工具在宿主编程语言中提供XPath/XQuery功能等。 ●第一步:建立dbml(Database Mark Language.数据库描述语言,是一种XML格式的文档, 用来描述数据库,有点类似Nhibernate的映射文件)

C# List中写出类似SQL的语句(即LINQ,写给新手)

C# List中写出类似SQL的语句（即LINQ，写给新手）本文是写给C#新手，老手就勿看了，讲的实际上就是LINQ，谢谢一楼的提醒。很多时候，从一个关系表中挑出一个我们需要的元素列表采用SQL语句是再容易不过的了，其实C#的List中也可以采用类似的方法，虽然List中集成了Select(), Where()等语句，不过如果你的判断规则较为复杂，或者想要看起来一目了然，以下的方法也是可行的：首先假设你有一个类 public class People { public string Name { get; set; } public int Age { get; set; } } 并且有一些初始化语句 List PeopleList = new List(); PeopleList.Add(new People() { Name = "Haocheng Wu", Age = 24 }); PeopleList.Add(new People() { Name = "Haocheng Wu", Age = 25 }); PeopleList.Add(new People() { Name = "James Wu", Age = 23 }); 你就可以采用下面类似于SQL语句的方法进行select List SubPeopleNameList1 = (from people in PeopleList where https://www.wendangku.net/doc/16392581.html, == "Haocheng Wu" && people.Age == 24 select https://www.wendangku.net/doc/16392581.html,).ToList(); 当然你也可以用一行代替 List SubPeopleNameList2 = PeopleList.Where(people => https://www.wendangku.net/doc/16392581.html, == "Haocheng Wu" && people.Age == 24).Select(people => https://www.wendangku.net/doc/16392581.html,).ToList(); 不过显然第一种方法更加一目了然，尤其是当判断条件相当复杂的时候就更加有用了

第8章使用LINQ进行数据访问

LINQ教程

1、LINQ表达式 LINQ语言集成查询（Language Integrated Query） LINQ 最明显的“语言集成”部分是查询表达式。查询表达式是使用C# 3.0 中引入的声明性查询语法编写的。通过使用查询语法，您甚至可以使用最少的代码对数据源执行复杂的筛选、排序和分组操作。您使用相同的基本查询表达式模式来查询和转换SQL 数据库、https://www.wendangku.net/doc/16392581.html, 数据集、XML 文档和流以及 .NET 集合中的数据。下面的示例演示了完整的查询操作。完整操作包括创建数据源、定义查询表达式，以及在foreach语句中执行查询。 class LINQQueryExpressions { staticvoid Main() { // Specify the data source. int[] scores = newint[] { 97, 92, 81, 60, 89, 45, 34, 78 }; // Define the query expression. IEnumerable scoreQuery = from score in scores where score > 80 select score; // Execute the query.

foreach (int i in scoreQuery) { Console.Write(i + " "); } } } // Output: 97 92 81 89

2、LINQ查询 “查询”是指一组指令，这些指令描述要从一个或多个给定数据源检索的数据以及返回的数据应该使用的格式和组织形式。查询不同于它所产生的结果。通常，源数据会在逻辑上组织为相同种类的元素序列。SQL 数据库表包含一个行序列。与此类似，https://www.wendangku.net/doc/16392581.html, DataTable 包含一个DataRow 对象序列。在XML 文件中，有一个XML 元素“序列”（不过这些元素按分层形式组织为树结构）。内存中的集合包含一个对象序列。从应用程序的角度来看，原始源数据的具体类型和结构并不重要。应用程序始终将源数据视为一个IEnumerable<(Of <(T>)>) 或IQueryable<(Of <(T>)>) 集合。在LINQ to SQL 中，源数据显示为一个 IEnumerable。在LINQ to DataSet 中，它是一个IEnumerable。在LINQ to SQL 中，它是您定义用来表示SQL 表中数据的任何自定义对象的IEnumerable 或IQueryable。检索一个元素子集以产生一个新序列，但不修改单个元素。然后，查询可以按各种方式对返回的序列进行排序或分组，如下面的示例所示（假定scores 是int[]）： IEnumerable highScoresQuery = from score in scores where score > 80

如何使用LINQ检索和操作数据库

如何使用LINQ检索和操作数据库日期：2009年7月10日作者：人气：35 查看:[大字体中字体小字体] 借助于LINQ提供的各种功能和独有的语法结构，LINQ已经被用来作为一种统一的数据库访问技术而被广泛使用，用以消除从数据访问层到数据源层出不穷的区别。通过LINQ检索，我们已经可以不用自己编写一行代码来从数据库获取到数据，LINQ和SQL之间提供了一个直接映射关系，它可以通过我们事先指定的数据库连接自动生成数据库实体类，而我们只需要通过LINQ语句操作这些实体对象就可以非常轻松地从数据库中获取到数据。当然，LINQ所生成的实体对象的功能远远不止这些，它甚至支持数据的更新和存储过程的调用，所有这些都可以通过简单的几行LINQ语句来完成，让我们真正摆脱了编写数据访问层、数据库实体类的工作。下面就让我们来看看LINQ的神奇功能吧！使用LINQ生成数据库实体类 Visual Studio 2008集成开发环境为我们提供了很多有用的功能来实现LINQ to SQL。为了让读者可以自行尝试本文所举的示例，读者可能需要在本地安装一个SQL Server数据库实例，Northwind是微软官方提供的一个不错的例子，如果你本地没有安装这个实例，可以去下面这个地址下载： https://www.wendangku.net/doc/16392581.html,/downloads/details.aspx?FamilyID=06616212-035 6-46A0-8DA2-EEBC53A68034&displaylang=en 我们在Visual Studio 2008中新建一个控制台应用程序，取名为LINQExample，然后打开Server Explorer窗口并连接到Northwind数据库。如果找不到Server Explorer窗口，可以通过View-Server Explorer菜单打开。在Server Explorer窗口中，右键单击Data Connection节点，选择Add Connection，在弹出的窗口中选择Northwind数据库。

LINQ基本语法及其示例

LINQ基本语法及其示例说明： 1、在未作任何说明的情况下，以下用到的db变量都是DataContext的实例对象，声明语法类似如下： using (BP_DataClassesDataContext db = new BP_DataClassesDataContext(ConnectionStrings.GetInstance("ZJ").Con)) { //Code } 2、默认q为Iqueryable类型变量简单查询： var q = from p in db.view_PreTestResultAuditList select p; 简单条件查询：方式一：直接使用where关键字 var q = from c in db.view_PrTestList where c.FTestmanID.Equals(UserContext.CurrentUser.FID) select c; 方式二：使用lambda 表达式 var q = db.TOriInfoAutoMemory.Where(c => c.FSampleName == sampleName); 使用&&和|| 带代替And或Or关键字： var entity = db.TSampleOriginalInfo.FirstOrDefault(c => c.FFromID.Equals(fromID) && c.FSampleID.Equals(sampleID)); like模糊条件查询： //使用C#中的Contains关键字代替SQL中的like关键字 q = q.Where(c => c.FTaskCode.Contains(https://www.wendangku.net/doc/16392581.html,)); In包含查询： /// string[] var certi = (from c in db.TMSCertificate where certificateIDs.ToList().Contains(c.FID.ToString()) select c).ToList(); 等价于：select * from TMSCertificate where FID in /* certificateIDs */ Skip和Take实现分页查询： var q = from c in db.view_PrTestList where c.FTestmanID.Equals(UserContext.CurrentUser.FID) select c; twi.data = (q.Skip(paging.startIndex).Take(paging.pageSize)).ToList(); //其中startIndex：跳过的系列中指定的条数 // pageSize：每页显示条数（记录数） Distinct方法去除重复： var p = (from c in dc.TSampleOriginalInfo where sampleIDs.Contains(c.FSampleID.ToString()) select new { c.FFromID,

Linq查询简介

莁LINQ 蒈LINQ，语言集成查询（Language INtegrated Query）是一组用于c#和Visual Basic语言的扩展。它允许编写C#或者Visual Basic代码以查询数据库相同的方式操作内存数据。肅基本概念螃从技术角度而言，LINQ定义了大约40个查询操作符，如select、from、in、where以及orderby（C#）中。试用这些操作可以编写查询语句。不过，这些查询还可以基于很多类型的数据，每个数据类型都需要一个单独的LINQ类型。肀经过了最近 20 年，面向对象编程技术（ object-oriented (OO) programming technologies ）在工业领域的应用已经进入了一个稳定的发展阶段。程序员现在都已经认同像类（classes）、对象（objects）、方法（methods）这样的语言特性。考察现在和下一代的技术，一个新的编程技术的重大挑战开始呈现出来，即面向对象技术诞生以来并没有解决降低访问和整合信息数据（ accessing and integrating information ）的复杂度的问题。其中两个最主要访问的数据源与数据库（ database ）和 XML 相关。蒈LINQ 提供了一条更常规的途径即给 .Net Framework 添加一些可以应用于所有信息源（ all sources of information ）的具有多种用途（ general-purpose ）的语法查询特性（ query facilities ），这是比向开发语言和运行时（ runtime ）添加一些关系数据（ relational ）特性或者类似 XML 特性（ XML-specific ）更好的方式。这些语法特性就叫做 .NET Language Integrated Query (LINQ) 。

LINQ增删改查

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; using https://www.wendangku.net/doc/16392581.html,mon; using System.Collections.Generic; namespace FirstLinq { public partial class _Default : System.Web.UI.Page { NorthwindDataContext ctx = new NorthwindDataContext("Data Sou rce=ZHANGSHUQIANG;Initial Catalog=Northwind;Persist Security Inf o=True;User ID=sa;Password=sa"); protected void Page_Load(object sender, EventArgs e) { Linq1(); Linq2(); Linq3(); } ///

///增删改查 ///

private void Linq3() { //增 t_User user = new t_User(); https://www.wendangku.net/doc/16392581.html,erName = "大气象"; user.Pwd = "123456"; ctx.t_User.InsertOnSubmit(user);//以前的方法是Add(); ctx.SubmitChanges(); //改 //参考这样的语法string s = (from a in ctx.Customers select a).Si ngle(a => a.ID == 2); t_User userUpdate = ctx.t_User.SingleOrDefault(t_User => t_Use r.ID == 2);//Single与SingleOrDefault没区别 https://www.wendangku.net/doc/16392581.html,erName = "大气象1"; ctx.SubmitChanges(); //删 t_User userDelete = (from userinfo in ctx.t_User where userinfo.I D == 1 select userinfo).FirstOrDefault(); if (userDelete != null) {

LINQ 基础

1LinQ初体验： 1.1Aaa int[] numbers = new int[] { 6, 4, 3, 2, 9, 1, 7, 8, 5 }; var even = numbers .Where(p => p % 2 == 0) .Select(p => p) .OrderByDescending(p => p); 2Lambda 表达式 ProcessString p = input => input.T oLower(); foreach (string name in foxRiver8) { Console.WriteLine( p ( name ) ) ; } 在C#里，一个lambda表达式在句法上是写成一个参数列表，随后是 => 符号，随后是表达式在调用时要运算的表达式或者语句块： params => expression 所以，当我们编写这样的lambda表达式时： p => https://www.wendangku.net/doc/16392581.html,stName == "Guthrie" 我们是想表示，我们在定义的Lambda接受一个参数p，要运行的代码表达式返回https://www.wendangku.net/doc/16392581.html,stName的值是否等于“Guthrie”。我们将参数命名为p是不相干的，我也可以很容易地将其命名为o，x，foo，或者我想要的任何名字。不象匿名方法要求参数类型是明确地指明的，Lambda表达式允许省略参数类型，而允许它们根据用法来推断出类型。譬如，当我编写 p=>https://www.wendangku.net/doc/16392581.html,stName == "Guthrie" 这个lambda表达式时，编译器推断出p参数属于Person类型，因为当前的Where扩展方法的对象是个范型的List< Person>集合。 Lambda参数的类型可以在编译时和被Visual Studio的intellisense引擎推断出来，这意味着在编写lambda时你将获得完全的intellisense 和编译时检查。譬如，注意当我在下面健入 p. 时，Visual Studio Orcas是如何提供intellisense完成的，因为它知道 p 是 Person类型：注: 假如你要给一个Lambda表达式明确地声明参数的类型的话，你可以在Lambda参数表里的参数名字前声明参数类型，象这样： 3Lambda表达式初步 3.1 A delegate string ProcessStr(string input); protected void Page_Load(object sender, EventArgs e) { var foxRiver = new string[] { "Mike", "Smith", "Tom", "Jack" };

LINQ体验(5)——LINQ to SQL语句之Select、Distinct和Count、Sum、Min、Max、Avg

上一篇讲述了LINQ，顺便说了一下Where操作，这篇开始我们继续说LINQ to SQL语句，目的让大家从语句的角度了解LINQ，LINQ包括LINQ to Objects、LINQ to DataSets、LINQ to SQL、LI NQ to Entities、LINQ to XML，但是相对来说LINQ to SQL在我们程序中使用最多，毕竟所有的数据都要在数据库运行着各种操作。所以先来学习LINQ to SQL，其它的都差不多了，那么就从Select 说起吧，这个在编写程序中也最为常用。本篇详细说明一下Select和Count/Sum/Min/Max/Avg。 Select/Distinct操作符适用场景：o(∩_∩)o… 查询呗。说明：和SQL命令中的select作用相似但位置不同，查询表达式中的select及所接子句是放在表达式最后并把子句中的变量也就是结果返回回来；延迟。 Select/Distinct操作包括9种形式，分别为简单形式、匿名类型形式、带条件形式、指定类型形式、过滤类型形式、shaped类型形式、嵌套类型形式、LocalMethodCall形式、Distinct形式。 1.简单形式：注意：这个语句只是一个声明或者一个描述，并没有真正把数据取出来，只有当你需要该数据的时候，它才会执行这个语句，这就是延迟加载(deferred loading)。如果，在声明的时候就返回的结果集是对象的集合。你可以使用ToList() 或ToArray()方法把查询结果先进行保存，然后再对这个集合进行查询。当然延迟加载(deferred loading)可以像拼接SQL语句那样拼接查询语法，再执行它。 2.匿名类型形式：说明：匿名类型是C#3.0中新特性。其实质是编译器根据我们自定义自动产生一个匿名的类来帮助我们实现临时变量的储存。匿名类型还依赖于另外一个特性：支持根据property来创建对象。比如，var d = new { Name = "s" };编译器自动产生一个有property叫做Name的匿名类，然后按这个类型分配内存，并初始化对象。但是var d = new {"s"};是编译不通过的。因为，编译器不知道匿名类中的p roperty的名字。例如string c = "d";var d = new { c}; 则是可以通过编译的。编译器会创建一个叫做匿名类带有叫c的property。例如下例：new{c,ContactName,c.Phone};ContactName和Phone都是在映射文件中定义与表中字段相对应的property。编译器读取数据并创建对象时，会创建一个匿名类，这个类有两个属性，为Cont actName和Phone，然后根据数据初始化对象。另外编译器还可以重命名property的名字。

Linq中的一些常用函数的使用总结

Linq中的一些常用函数的使用 2010-11-24 10:00 Select/Distinct操作符适用场景：o(∩_∩)o… 查询呗。说明：和SQL命令中的select作用相似但位置不同，查询表达式中的select及所接子句是放在表达式最后并把子句中的变量也就是结果返回回来；延迟。 Select/Distinct操作包括9种形式，分别为简单形式、匿名类型形式、带条件形式、指定类型形式、过滤类型形式、shaped类型形式、嵌套类型形式、LocalMethodCall形式、Distinct形式。 1.简单形式： var q = from c in db.Customers select c.ContactName; 注意：这个语句只是一个声明或者一个描述，并没有真正把数据取出来，只有当你需要该数据的时候，它才会执行这个语句，这就是延迟加载(deferred loading)。如果，在声明的时候就返回的结果集是对象的集合。你可以使用ToList() 或ToArray()方法把查询结果先进行保存，然后再对这个集合进行查询。当然延迟加载(deferred loading)可以像拼接SQL语句那样拼接查询语法，再执行它。 2.匿名类型形式：说明：匿名类型是C# 3.0中新特性。其实质是编译器根据我们自定义自动产生一个匿名的类来帮助我们实现临时变量的储存。匿名类型还依赖于另外一个特性：支持根据property来创建对象。比如，var d = new { Name = "s" };编译器自动产生一个有property叫做Name的匿名类，然后按这个类型分配内存，并初始化对象。但是var d = new {"s"};是编译不通过的。因为，编译器不知道匿名类中的property的名字。例如string c = "d";var d = new { c}; 则是可以通过编译的。编译器会创建一个叫做匿名类带有叫c的property。例如下例：new{c,ContactName,c.Phone};ContactName和Phone都是在映射文件中定义与表中字段相对应的property。编译器读取数据并创建对象时，会创建一个匿名类，这个类有两个属性，为ContactName和Phone，然后根据数据初始化对象。另外编译器还可以重命名property 的名字。 var q = from c in db.Customers select new {c.ContactName, c.Phone}; 语句描述：查询顾客的联系人和电话。 var q = from e in db.Employees select new {Name = e.FirstName + " " + https://www.wendangku.net/doc/16392581.html,stName, Phone = e.HomePhone}; 语句描述：查询职员的姓名和家庭电话

Linq使用

在过去的几个月中我写了一系列涵盖了VS和.NET Framework Orcas版中的一些新特性的帖子，下面是这些帖子的链接：自动属性，对象初始化器，和集合初始化器扩展方法 Lambda表达式查询句法匿名类型以上的语言特性帮助数据查询成为一等编程概念。我们称这个总的查询编程模型为“LINQ”－－它指的是.NET语言级集成查询。开发者可以在任何的数据源上使用LINQ。他们可以在他们选择的编程语言中表达高效的查询行为，选择将查询结果转换或构形成他们想要的任何格式，然后非常方便地操作这个结果集。有LINQ功能的语言可以提供完全的类型安全和查询表达式的编译时检查，而开发工具则可以提供在编写LINQ代码时完全的智能感知，调试，和丰富的重构支持。 LINQ支持一个非常丰富的的扩展性模型，该模型将有助于对不同的数据源生成不同的高效运算因子（domain-specific operators）。.NET Framework的Orcas版本将发布一些内置库，这些库提供了针对对象（Objects），XML，和数据库的LINQ支持。什么是LINQ to SQL？ LINQ to SQL 是随.NET Framework Orcas版一起发布的O/RM(对象关系映射）实现，它允许你用.NET 的类来对一个关系型数据库建模。然后你可以用LINQ对数据库进行查询，以及进行更新/插入/删除数据的操作。 LINQ to SQL完全支持事务，视图和存储过程。它还提供了一种把数据验证和业务逻辑规则结合进你的数据模型的便利方式。使用LINQ to SQL对数据库建模： Visual Studio Orcas版中提供了一个LINQ to SQL设计器，该设计器提供了一种简易的方式，将数据库可视化地转换为LINQ to SQL对象模型。我下一篇博客将会更深入一些来介绍怎么使用该设计器（你可以观看我一月份时录制的这个关于如何从头开始创建LINQ to SQL 模型的录像）。通过LINQ to SQL设计器，我可以方便地设计出如下所示的Northwind数据库的示例模型：

一、Linq有两种语法

一、Linq有两种语法： 1、方法语法 2、查询语法下面举个例子看看这两种方法的区别比如现在有一个学生类 public class student { public string username { get; set; } public int age { get; set; } public string sex { get; set; } } 我们通过一个方法来添加很多同学 public IList GetStu(int n) { IList stuList = new List(); for (int i = 0; i < n; i++) { student stu = new student(); stu.age = 25 + i; stu.sex = "男" + i; https://www.wendangku.net/doc/16392581.html,ername = "张三" + i; stuList.Add(stu); } return stuList; } 那么这个方法返回的就是一个list集合，下面我们就可以通过linq对这个集合进行操作首先我们来查询所有的学生 A、查询语法： var list = GetStu(10); var result = from s in list select new { stuname=https://www.wendangku.net/doc/16392581.html,ername,sex=s.sex,age=s.age}; 这是linq常用的语法from 变量 in 集合 Select 变量 B、方法语法 var result1 = list.Select(s1 => new{ username = https://www.wendangku.net/doc/16392581.html,ername, age = s1.age, sex = s1.sex }); 这就是方法语法，符合一般的C#语法这两种方法的执行结果是一样的，唯一的区别就是语法二、输出的方式输出的方式也有两种，我们知道linq主要对集合进行操作的，所以一般都需要循环输出第一种输出方式： string stt = null; foreach (var sa in result3)

LINQ TO SQL 连接查询与联合查询

LINQ TO SQL 连接查询与联合查询 Join操作适用场景：在我们表关系中有一对一关系，一对多关系，多对多关系等。对各个表之间的关系，就用这些实现对多个表的操作。说明：在Join操作中，分别为Join(Join查询), SelectMany(Select一对多选择)和Gro upJoin(分组Join查询)。该扩展方法对两个序列中键匹配的元素进行inner join操作 SelectMany 说明：我们在写查询语句时，如果被翻译成SelectMany需要满足2个条件。1：查询语句中没有join和into，2：必须出现EntitySet。在我们表关系中有一对一关系，一对多关系，多对多关系等，下面分别介绍一下。 1.一对多关系(1 to Many)：语句描述：Customers与Orders是一对多关系。即Orders在Customers类中以Enti tySet形式出现。所以第二个from是从c.Orders而不是db.Orders里进行筛选。这个例子在From子句中使用外键导航选择伦敦客户的所有订单。语句描述：这一句使用了p.Supplier.Country条件，间接关联了Supplier表。这个例子在Where子句中使用外键导航筛选其供应商在美国且缺货的产品。生成SQL语句为：

2.多对多关系(Many to Many)：说明：多对多关系一般会涉及三个表(如果有一个表是自关联的，那有可能只有2个表)。这一句语句涉及Employees, EmployeeTerritories, Territories三个表。它们的关系是1：M：1。Employees和Territories没有很明确的关系。语句描述：这个例子在From子句中使用外键导航筛选在西雅图的雇员，同时列出其所在地区。这条生成SQL语句为：