全部分类
搜索资料
    首页 目前本人收集的最全的LINQ入门资料~~大家一起LINQ吧

    目前本人收集的最全的LINQ入门资料~~大家一起LINQ吧

    举报
    开通vip

    目前本人收集的最全的LINQ入门资料~~大家一起LINQ吧目前本人收集的最全的LINQ入门资料~~大家一起LINQ吧 入门教程系列1 Linq to Sql(一):DataContext与实体 Linq to Sql(二):增删改 Linq to Sql(三):查询句法 Linq to Sql(四):存储过程 Linq to Sql(五):探究特性 Linq to Sql(六):并发与事务 Linq to Sql(七):继承与关系 Linq to sql(八):其它 入门教程系列2 LINQ体验(1)——Visual Studio 2008新特性 ...

    目前本人收集的最全的LINQ入门资料~~大家一起LINQ吧
    目前本人收集的最全的LINQ入门资料~~大家一起LINQ吧 入门教程系列1 Linq to Sql(一):DataContext与实体 Linq to Sql(二):增删改 Linq to Sql(三):查询句法 Linq to Sql(四):存储过程 Linq to Sql(五):探究特性 Linq to Sql(六):并发与事务 Linq to Sql(七):继承与关系 Linq to sql(八):其它 入门教程系列2 LINQ体验(1)——Visual Studio 2008新特性 我平时利用课余零碎时间来学习ASP.NET3.5、LINQ、Silverlight、ASP.NET3.5Extensions等新东西，通过笔记形式来记录自己所学的历程，也给大家一起学习Visual Studio 2008和.NET3.5提供一个平台，为保证此系列的完整性，我打算先依次介绍一下C#3.0新语言特性和改进，然后从一条一条LINQ语句分析来贯穿LINQ的知识点…… LINQ体验(2)——C# 3.0新语言特性和改进(上篇) LINQ体验(3)——C# 3.0新语言特性和改进(下篇) LINQ体验(4)——LINQ简介和LINQ to SQL语句之Where LINQ是LanguageIntegratedQuery的简称，它是集成在.NET编程语言中的一种特性。已成为编程语言的一个组成部分，在编写程序时可以得到很好的编译时语法检查，丰富的元数据，智能感知、静态类型等强类型语言的好处。并且它同时还使得查询可以方便地对内存中的信息进行查询而不仅仅只是外部数据源。… LINQ体验(5)——LINQ to SQL语句之Select/Distinct和Count/Sum/Min/Max/Avg LINQ体验(6)——LINQ to SQL语句之Join和Order By LINQ体验(7)——LINQ to SQL语句之Group By/Having和Exists/In/Any/All/Contains 我们继续讲解LINQ to SQL语句，这篇我们来讨论Group By/Having操作符和Exists/In/Any/All/Contains操作符。…… LINQ体验(8)——LINQ to SQL语句之Union All/Union/Intersect和Top/Bottom和Paging和SqlMethods 我们继续讲解LINQ to SQL语句，这篇我们来讨论Union All/Union/Intersect操作和Top/Bottom操作和Paging操作和SqlMethods操作 。…… LINQ体验(9)——LINQ to SQL语句之Insert/Update/Delete操作 这篇我们来讨论LINQ的Insert/Update/Delete操作。这个在我们的程序中最为常用了。我们直接看例子。…… LINQ体验(10)——LINQ to SQL语句之开放式并发控制和事务 从今天开始继续这个系列。告诉大家一个好消息:微软于2月1日发布了Visual Studio Team System2008TeamSuite简体中文版，您可以在这里下载Visual Studio Team System 2008TeamSuite简体中文版90天试用版。今天简单的学习下开放式并发控制和事务的内容， 具体详细的内容现在可以参看MSDN了。 LINQ体验(11)——LINQ to SQL语句之Null语义和String/DateTime 方法 快递客服问题件处理详细方法山木方法pdf计算方法pdf华与华方法下载八字理论方法下载 在本系列中，主要介绍LINQtoSQL基础的东西，因为LINQ太强大了，它对我们平常使用不同的数据源有着不同的内容，其包括对于SQLServer 数据库的LINQtoSQL;对于XML 文档的LINQ to XML;对于 ADO.NET 数据集的LINQtoDataSet;对于.NET集合、文件、字符串等的LINQ to Objects。 LINQ体验(12)——LINQ to SQL语句之对象标识和对象加载 实际上，通常我们是将数据从数据库中提取出来放入另一层中，应用程序在该层对数据进行处理。这就是 LINQtoSQL支持的模型。将数据作为行从数据库中提取出来时，你不期望表示相同数据的两行实际上对应于相同的行实例。如果您查询特定客户两次，您将获得两行数据。每一行包含相同的信息。 LINQ体验(13)——LINQ to SQL语句之运算符转换和ADO.NET与LINQ to SQL LINQ体验(14)——LINQ to SQL语句之存储过程 在我们编写程序中，往往需要一些存储过程，在LINQ to SQL中怎么使用呢,也许比原来的更简单些。下面我们以NORTHWND.MDF数据库中自带的几个存储过程来理解一下。 LINQ体验(15)——LINQ to SQL语句之用户定义函数 我们可以在LINQ to SQL中使用用户定义函数。只要把用户定义函数拖到O/R 设计 领导形象设计圆作业设计ao工艺污水处理厂设计附属工程施工组织设计清扫机器人结构设计 器中，LINQtoSQL自动使用FunctionAttribute属性和ParameterAttribute属性(如果需要)将其函数指定为方法。这时，我们只需简单调用即可。 LINQ体验(16)——LINQ to SQL语句之DataContext DataContext作为LINQ to SQL框架的主入口点，为我们提供了一些方法和属性，本文用几个例子说明DataContext几个典型的应用。 LINQ体验(17)——LINQ to SQL语句之动态查询 LINQ体验(18)——LINQ to SQL语句之视图和继承支持 我们使用视图和使用数据表类似，只需将视图从“服务器资源管理器/数据库资源管理器”拖动到O/R设计器上，自动可以创建基于这些视图的实体类。我们可以同操作数据表一样来操作视图了。这里注意:O/R设计器是一个简单的对象关系映射器，因为它仅支持 1:1 映射关系。 Linq to Sql(一):DataContext与实体 DataContext DataContext类型(数据上下文)是System.Data.Linq命名空间下的重要类型，用于把查询句法翻译成SQL语句，以及把数据从数据库返回给调用方和把实体的修改写入数据库。 DataContext提供了以下一些使用的功能: , 以日志形式记录DataContext生成的SQL , 执行SQL(包括查询和更新语句) , 创建和删除数据库 DataContext是实体和数据库之间的桥梁，那么首先我们需要定义映射 到数据表的实体。 定义实体类 using System.Data.Linq.Mapping; [Table(Name = "Customers")] public class Customer { [Column(IsPrimaryKey = true)] public string CustomerID {get; set;} [Column(Name = "ContactName")] public string Name { get; set; } [Column] public string City {get; set;} } 以Northwind数据库为例，上述Customers类被映射成一个表，对应数据库中的 Customers表。然后在类型中定义了三个属性，对应表中的三个字段。其中，CustomerID字段是主键，如果没有指定Column特性的Name属性，那么系统会把属性名作为数据表的字段名，也就是说实体类的属性名就需要和数据表中的字段名一致。 现在，创建一个ASP.NET页面，然后在页面上加入一个GridView控件，使用下面的代码进行绑定数据: using System.Data.Linq; DataContext ctx = new DataContext("server=xxx;database=Northwind;uid=xxx;pwd=xxx"); Table Customers = ctx.GetTable(); GridView1.DataSource = from c in Customers where c.CustomerID.StartsWith("A") select new {顾客ID=c.CustomerID, 顾客名=c.Name, 城市=c.City}; GridView1.DataBind(); 使用DataContext类型把实体类和数据库中的数据进行关联。你可以直接在DataContext的构造方法中定义连接字符串，也可以使用IDbConnection: using System.Data.SqlClient; IDbConnection conn = new SqlConnection("server=xxx;database=Northwind;uid=xxx;pwd=xxx"); DataContext ctx = new DataContext(conn); 之后，通过GetTable获取表示底层数据表的Table类型，显然，数据库中的Customers表的实体是Customer类型。随后的查询句法，即使你不懂SQL应该也能看明白。从Customers表中找出CustomerID以“A”开头的记录，并把CustomersID、Name以及City封装成新的匿名类型进行返回。 结果如下图: 强类型DataContext public partial class NorthwindDataContext : DataContext { public Table Customers; public NorthwindDataContext(IDbConnection connection) : base(connection) { } public NorthwindDataContext(string connection) : base(connection) { } } 强类型数据上下文使代码更简洁: NorthwindDataContext ctx = new NorthwindDataContext("server=xxx;database=Northwind;uid=xxx;pwd=xxx"); GridView1.DataSource = from c in ctx.Customers where c.CustomerID.StartsWith("A") select new { 顾客ID = c.CustomerID, 顾客名 = c.Name, 城市 = c.City }; GridView1.DataBind(); DataContext其实封装了很多实用的功能，下面一一介绍。 日志功能 using System.IO; NorthwindDataContext ctx = new NorthwindDataContext("server=xxx;database=Northwind;uid=xxx;pwd=xxx"); StreamWriter sw = new StreamWriter(Server.MapPath("log.txt"), true); // Append ctx.Log = sw; GridView1.DataSource = from c in ctx.Customers where c.CustomerID.StartsWith("A") select new { 顾客ID = c.CustomerID, 顾客名 = c.Name, 城市 = c.City }; GridView1.DataBind(); sw.Close(); 运行程序后在网站所在 目录 工贸企业有限空间作业目录特种设备作业人员作业种类与目录特种设备作业人员目录1类医疗器械目录高值医用耗材参考目录 生成了log.txt，每次查询都会把诸如下面的日志追加到文本文件中: SELECT [t0].[CustomerID], [t0].[ContactName], [t0].[City] FROM [Customers] AS [t0] WHERE [t0].[CustomerID] LIKE @p0 -- @p0: Input String (Size = 2; Prec = 0; Scale = 0) [A%] -- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.20706.1 应该说这样的日志对于调试程序是非常有帮助的。 探究查询 using System.Data.Common; using System.Collections.Generic; NorthwindDataContext ctx = new NorthwindDataContext("server=xxx;database=Northwind;uid=xxx;pwd=xxx"); var select = from c in ctx.Customers where c.CustomerID.StartsWith("A") select new { 顾客ID = c.CustomerID, 顾客名 = c.Name, 城市 = c.City }; DbCommand cmd = ctx.GetCommand(select); Response.Write(cmd.CommandText + "
    "); foreach (DbParameter parm in cmd.Parameters) Response.Write(string.Format("参数名:{0},参数值:{1}
    ", parm.ParameterName, parm.Value)); Customer customer = ctx.Customers.First(); customer.Name = "zhuye"; IList queryText = ctx.GetChangeSet().ModifiedEntities; Response.Write(((Customer)queryText[0]).Name); 在这里，我们通过DataContext的GetCommand方法获取了查询对应的DbCommand，并且输出了CommandText和所有的DbParameter。之后，我们又通过GetChangeSet方法获取了修改后的实体，并输出了修改内容。 执行查询 NorthwindDataContext ctx = new NorthwindDataContext("server=xxx;database=Northwind;uid=xxx;pwd=xxx"); string newcity = "Shanghai"; ctx.ExecuteCommand("update Customers set City={0} where CustomerID like 'A%'", newcity); IEnumerable customers = ctx.ExecuteQuery("select * from Customers where CustomerID like 'A%'"); GridView1.DataSource = customers; GridView1.DataBind(); 前一篇文章已经说了，虽然Linq to sql能实现90,以上的TSQL功能。但是不可否认，对于复杂的查询，使用TSQL能获得更好的效率。因此，DataContext类型也提供了执行SQL语句的能力。代码的执行结果如下图: 创建数据库 testContext ctx = new testContext("server=xxx;database=testdb;uid=xxx;pwd=xxx"); ctx.CreateDatabase(); [Table(Name = "test")] public class test { [Column(IsPrimaryKey = true, IsDbGenerated = true)] public int ID { get; set; } [Column(DbType="varchar(20)")] public string Name { get; set; } } public partial class testContext : DataContext { public Table test; public testContext(string connection) : base(connection) { } } 这段代码在数据库中创建了名为testdb的数据库，等同于下面的脚本: CREATE TABLE [dbo].[test]( [ID] [int] IDENTITY(1,1) NOT NULL, [Name] [varchar](20) COLLATE Chinese_PRC_CI_AS NULL, CONSTRAINT [PK_test] PRIMARY KEY CLUSTERED ( [ID] ASC )WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY] ) ON [PRIMARY] 同时，DataContext还提供了DeleteDatabase()方法，在这里就不列举了。 使用DbDataReader数据源 using System.Data.SqlClient; var conn = new SqlConnection("server=xxx;database=Northwind;uid=xxx;pwd=xxx"); var ctx = new DataContext(conn); var cmd = new SqlCommand("select * from customers where CustomerID like 'A%'", conn); conn.Open(); var reader = cmd.ExecuteReader(); GridView1.DataSource = ctx.Translate(reader); GridView1.DataBind(); conn.Close(); 你同样可以选择使用DataReader获取数据，增加了灵活性的同时也增加了性能。 看到这里，你可能会觉得手工定义和数据库中表对应的实体类很麻烦，不用担心，VS2008提供了自动生成实体类以及关系的工具，工具的使用 将在以后讲解。今天就讲到这里，和DataContext相关的事务、加载选项、并发选项以及关系实体等高级内容也将在以后讲解。 Linq to Sql(二):增删改 示例数据库 字段名 字段类型 允许空 字段说明 ID uniqueidentifier 表主键字段 UserName varchar(50) 留言用户名 PostTime datetime 留言时间 Message varchar(400) ? 留言内容 IsReplied bit 留言是否回复 Reply varchar(400) ? 留言管理员回复 在数据库中创建一个名为GuestBook的数据库，在里面创建一个tbGuestBook的表，结构如上表。 生成实体类 右键点击网站项目，选择添加新项，然后选择“Linq to sql Classes”，命名为GuestBook。然后打开App_Code里面的GuestBook.dbml。设计视图上的文字提示你可以从服务器资源管理器或者攻击箱拖动项到设计界面上来创建实体类。 那么，我们就在服务器资源管理器中创建一个指向GuestBook数据库的数据连接，然后把tbGuestBook表拖动到GuestBook.dbml的设计视图上，按CTRL+S保存。打开GuestBook.designer.cs可以发现系统自动创建了GuestBook数据库中tbGuestBook表的映射，如下图: 简易留言簿 现在，我们就可以使用Linq to sql完成简易留言簿了。实现以下功能: , 发表留言(增) , 查看留言(查) , 管理员回复留言(改) , 管理员删除留言(删除) 首先，创建一个Default.aspx，在页面上加入一些控件:
    姓名

    留言



    <%# Eval("Message")%> <%# Eval("PostTime")%> - <%# Eval("UserName")%>
    管理员回复:<%# Eval("IsReplied").ToString() == "False" ? "暂无" : Eval("Reply")%>

    你可能很难想象，使用Linq to sql进行数据访问会是这么简单，后台 代码: public partial class _Default : System.Web.UI.Page { GuestBookDataContext ctx = new GuestBookDataContext("server=xxx;database=GuestBook;uid=xxx;pwd=xxx"); protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { SetBind(); } } protected void btn_SendMessage_Click(object sender, EventArgs e) { tbGuestBook gb = new tbGuestBook(); gb.ID = Guid.NewGuid(); gb.UserName = tb_UserName.Text; gb.Message = tb_Message.Text; gb.IsReplied = false; gb.PostTime = DateTime.Now; ctx.tbGuestBooks.Add(gb); ctx.SubmitChanges(); SetBind(); } private void SetBind() { rpt_Message.DataSource = from gb in ctx.tbGuestBooks orderby gb.PostTime descending select gb; rpt_Message.DataBind(); } } 前面创建Linq to sql Classes的时候我们输入名字GuestBook，系统就为我们自动创建了GuestBookDataContext(你也可以在 GuestBook.Designer.cs中找到类定义)。在绑定的时候我们使用查询句法查询留言表中所有留言，按照发表时间倒序(天哪,这是数据访问吗,好像仅仅定义了一句SQL啊)。在发表留言按钮中，我们为一个tbGuestBook赋值，然后把它加入留言表，再提交更改，就这样完成了记录的插入。 运行效果如下图: 然后，再创建一个Admin.aspx，前台代码如下:
    <%# Eval("Message")%> <%# Eval("PostTime")%> - <%# Eval("UserName")%>
    管理员回复:

    后台代码: public partial class Admin : System.Web.UI.Page { GuestBookDataContext ctx = new GuestBookDataContext("server=xxx;database=GuestBook;uid=xxx;pwd=xxx"); protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { SetBind(); } } private void SetBind() { rpt_Message.DataSource = from gb in ctx.tbGuestBooks orderby gb.PostTime descending select gb; rpt_Message.DataBind(); } protected void rpt_Message_ItemCommand(object source, RepeaterCommandEventArgs e) { if (e.CommandName == "DeleteMessage") { StreamWriter sw = new StreamWriter(Server.MapPath("log.txt"), true); ctx.Log = sw; tbGuestBook gb = ctx.tbGuestBooks.Single(b => b.ID == new Guid(e.CommandArgument.ToString())); ctx.tbGuestBooks.Remove(gb); ctx.SubmitChanges(); SetBind(); sw.Close(); } if (e.CommandName == "SendReply") { StreamWriter sw = new StreamWriter(Server.MapPath("log.txt"), true); ctx.Log = sw; tbGuestBook gb = ctx.tbGuestBooks.Single(b => b.ID == new Guid(e.CommandArgument.ToString())); gb.Reply = ((TextBox)e.Item.FindControl("tb_Reply")).Text; gb.IsReplied = true; ctx.SubmitChanges(); SetBind(); sw.Close(); } } } 运行效果如下图: 在这里，我们通过Single方法获取一条记录，也就是一个tbGuestBook实例，更新了一些属性后保存也就完成了改这个操作。删除操作更简单，只需要从表中移除对象。你是不是觉得好像不是在操作数据库，像在操作内存中的对象。 由于写了日志，看看改和删操作会是怎么样的SQL, UPDATE [dbo].[tbGuestBook] SET [IsReplied] = @p4, [Reply] = @p5 WHERE ([ID] = @p0) AND ([UserName] = @p1) AND ([PostTime] = @p2) AND ([Message] = @p3) AND (NOT ([IsReplied] = 1)) AND ([Reply] IS NULL) -- @p0: Input Guid (Size = 0; Prec = 0; Scale = 0) [00000000-0000-0000-0000] -- @p1: Input String (Size = 4; Prec = 0; Scale = 0) [ghgh] -- @p2: Input DateTime (Size = 0; Prec = 0; Scale = 0) [2007-8-16 10:20:09] -- @p3: Input String (Size = 3; Prec = 0; Scale = 0) [ghj] -- @p4: Input Boolean (Size = 0; Prec = 0; Scale = 0) [True] -- @p5: Input String (Size = 3; Prec = 0; Scale = 0) [qqq] -- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.20706.1 DELETE FROM [dbo].[tbGuestBook] WHERE ([ID] = @p0) AND ([UserName] = @p1) AND ([PostTime] = @p2) AND ([Message] = @p3) AND (NOT ([IsReplied] = 1)) AND ([Reply] = @p4) -- @p0: Input Guid (Size = 0; Prec = 0; Scale = 0) [158ec941-13ff-4093-bd8b-9fceae152171] -- @p1: Input String (Size = 2; Prec = 0; Scale = 0) [44] -- @p2: Input DateTime (Size = 0; Prec = 0; Scale = 0) [2007-8-16 9:56:19] -- @p3: Input String (Size = 2; Prec = 0; Scale = 0) [44] -- @p4: Input String (Size = 3; Prec = 0; Scale = 0) [222] -- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 3.5.20706.1 Linq to Sql(三):查询句法 select 描述:查询顾客的公司名、地址信息 查询句法: var 构建匿名类型1 = from c in ctx.Customers select new { 公司名 = c.CompanyName, 地址 = c.Address }; 对应SQL: SELECT [t0].[CompanyName], [t0].[Address] FROM [dbo].[Customers] AS [t0] 描述:查询职员的姓名和雇用年份 查询句法: var 构建匿名类型2 = from emp in ctx.Employees select new { 姓名 = emp.LastName + emp.FirstName, 雇用年 = emp.HireDate.Value.Year }; 对应SQL: SELECT [t0].[LastName] + [t0].[FirstName] AS [value], DATEPART(Year, [t0].[HireDate]) AS [value2] FROM [dbo].[Employees] AS [t0] 描述:查询顾客的ID以及联系信息(职位和联系人) 查询句法: var 构建匿名类型3 = from c in ctx.Customers select new { ID = c.CustomerID, 联系信息 = new { 职位 = c.ContactTitle, 联系人 = c.ContactName } }; 对应SQL: SELECT [t0].[CustomerID], [t0].[ContactTitle], [t0].[ContactName] FROM [dbo].[Customers] AS [t0] 描述:查询订单号和订单是否超重的信息 查询句法: var select带条件 = from o in ctx.Orders select new { 订单号 = o.OrderID, 是否超重 = o.Freight > 100 ? "是" : "否" }; 对应SQL: SELECT [t0].[OrderID], (CASE WHEN [t0].[Freight] > @p0 THEN @p1 ELSE @p2 END) AS [value] FROM [dbo].[Orders] AS [t0] -- @p0: Input Currency (Size = 0; Prec = 19; Scale = 4) [100] -- @p1: Input String (Size = 1; Prec = 0; Scale = 0) [是] -- @p2: Input String (Size = 1; Prec = 0; Scale = 0) [否] where 描述:查询顾客的国家、城市和订单数信息，要求国家是法国并且订单数大于5 查询句法: var 多条件 = from c in ctx.Customers where c.Country == "France" && c.Orders.Count > 5 select new { 国家 = c.Country, 城市 = c.City, 订单数 = c.Orders.Count }; 对应SQL: SELECT [t0].[Country], [t0].[City], ( SELECT COUNT(*) FROM [dbo].[Orders] AS [t2] WHERE [t2].[CustomerID] = [t0].[CustomerID] ) AS [value] FROM [dbo].[Customers] AS [t0] WHERE ([t0].[Country] = @p0) AND ((( SELECT COUNT(*) FROM [dbo].[Orders] AS [t1] WHERE [t1].[CustomerID] = [t0].[CustomerID] )) > @p1) -- @p0: Input String (Size = 6; Prec = 0; Scale = 0) [France] -- @p1: Input Int32 (Size = 0; Prec = 0; Scale = 0) [5] orderby 描述:查询所有没有下属雇员的雇用年和名，按照雇用年倒序，按照名正序 查询句法: var 排序 = from emp in ctx.Employees where emp.Employees.Count == 0 orderby emp.HireDate.Value.Year descending, emp.FirstName ascending select new { 雇用年 = emp.HireDate.Value.Year, 名 = emp.FirstName }; 对应SQL: SELECT DATEPART(Year, [t0].[HireDate]) AS [value], [t0].[FirstName] FROM [dbo].[Employees] AS [t0] WHERE (( SELECT COUNT(*) FROM [dbo].[Employees] AS [t1] WHERE [t1].[ReportsTo] = [t0].[EmployeeID] )) = @p0 ORDER BY DATEPART(Year, [t0].[HireDate]) DESC, [t0].[FirstName] -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [0] 分页 描述:按照每页10条记录，查询第二页的顾客 查询句法: var 分页 = (from c in ctx.Customers select c).Skip(10).Take(10); 对应SQL: SELECT TOP 10 [t1].[CustomerID], [t1].[CompanyName], [t1].[ContactName], [t1].[ContactTitle], [t1].[Address], [t1].[City], [t1].[Region], [t1].[PostalCode], [t1].[Country], [t1].[Phone], [t1].[Fax] FROM ( SELECT ROW_NUMBER() OVER (ORDER BY [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax]) AS [ROW_NUMBER], [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] ) AS [t1] WHERE [t1].[ROW_NUMBER] > @p0 -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [10] 分组 描述:根据顾客的国家分组，查询顾客数大于5的国家名和顾客数 查询句法: var 一般分组 = from c in ctx.Customers group c by c.Country into g where g.Count() > 5 orderby g.Count() descending select new { 国家 = g.Key, 顾客数 = g.Count() }; 对应SQL: SELECT [t1].[Country], [t1].[value3] AS [顾客数] FROM ( SELECT COUNT(*) AS [value], COUNT(*) AS [value2], COUNT(*) AS [value3], [t0].[Country] FROM [dbo].[Customers] AS [t0] GROUP BY [t0].[Country] ) AS [t1] WHERE [t1].[value] > @p0 ORDER BY [t1].[value2] DESC -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [5] 描述:根据国家和城市分组，查询顾客覆盖的国家和城市 查询句法: var 匿名类型分组 = from c in ctx.Customers group c by new { c.City, c.Country } into g orderby g.Key.Country, g.Key.City select new { 国家 = g.Key.Country, 城市 = g.Key.City }; 对应SQL: SELECT [t1].[Country], [t1].[City] FROM ( SELECT [t0].[City], [t0].[Country] FROM [dbo].[Customers] AS [t0] GROUP BY [t0].[City], [t0].[Country] ) AS [t1] ORDER BY [t1].[Country], [t1].[City] 描述:按照是否超重条件分组，分别查询订单数量 查询句法: var 按照条件分组 = from o in ctx.Orders group o by new { 条件 = o.Freight > 100 } into g select new { 数量 = g.Count(), 是否超重 = g.Key.条件 ? "是" : "否" }; 对应SQL: SELECT (CASE WHEN [t2].[value2] = 1 THEN @p1 ELSE @p2 END) AS [value], [t2].[value] AS [数量] FROM ( SELECT COUNT(*) AS [value], [t1].[value] AS [value2] FROM ( SELECT (CASE WHEN [t0].[Freight] > @p0 THEN 1 WHEN NOT ([t0].[Freight] > @p0) THEN 0 ELSE NULL END) AS [value] FROM [dbo].[Orders] AS [t0] ) AS [t1] GROUP BY [t1].[value] ) AS [t2] -- @p0: Input Currency (Size = 0; Prec = 19; Scale = 4) [100] -- @p1: Input String (Size = 1; Prec = 0; Scale = 0) [是] -- @p2: Input String (Size = 1; Prec = 0; Scale = 0) [否] distinct 描述:查询顾客覆盖的国家 查询句法: var 过滤相同项 = (from c in ctx.Customers orderby c.Country select c.Country).Distinct(); 对应SQL: SELECT DISTINCT [t0].[Country] FROM [dbo].[Customers] AS [t0] union 描述:查询城市是A打头和城市包含A的顾客并按照顾客名字排序 查询句法: var 连接并且过滤相同项 = (from c in ctx.Customers where c.City.Contains("A") select c).Union (from c in ctx.Customers where c.ContactName.StartsWith("A") select c).OrderBy(c => c.ContactName); 对应SQL: SELECT [t3].[CustomerID], [t3].[CompanyName], [t3].[ContactName], [t3].[ContactTitle], [t3].[Address], [t3].[City], [t3].[Region], [t3].[PostalCode], [t3].[Country], [t3].[Phone], [t3].[Fax] FROM ( SELECT [t2].[CustomerID], [t2].[CompanyName], [t2].[ContactName], [t2].[ContactTitle], [t2].[Address], [t2].[City], [t2].[Region], [t2].[PostalCode], [t2].[Country], [t2].[Phone], [t2].[Fax] FROM ( SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] LIKE @p0 UNION SELECT [t1].[CustomerID], [t1].[CompanyName], [t1].[ContactName], [t1].[ContactTitle], [t1].[Address], [t1].[City], [t1].[Region], [t1].[PostalCode], [t1].[Country], [t1].[Phone], [t1].[Fax] FROM [dbo].[Customers] AS [t1] WHERE [t1].[ContactName] LIKE @p1 ) AS [t2] ) AS [t3] ORDER BY [t3].[ContactName] -- @p0: Input String (Size = 3; Prec = 0; Scale = 0) [%A%] -- @p1: Input String (Size = 2; Prec = 0; Scale = 0) [A%] concat 描述:查询城市是A打头和城市包含A的顾客并按照顾客名字排序，相同的顾客 信息不会过滤 查询句法: var 连接并且不过滤相同项 = (from c in ctx.Customers where c.City.Contains("A") select c).Concat (from c in ctx.Customers where c.ContactName.StartsWith("A") select c).OrderBy(c => c.ContactName); 对应SQL: SELECT [t3].[CustomerID], [t3].[CompanyName], [t3].[ContactName], [t3].[ContactTitle], [t3].[Address], [t3].[City], [t3].[Region], [t3].[PostalCode], [t3].[Country], [t3].[Phone], [t3].[Fax] FROM ( SELECT [t2].[CustomerID], [t2].[CompanyName], [t2].[ContactName], [t2].[ContactTitle], [t2].[Address], [t2].[City], [t2].[Region], [t2].[PostalCode], [t2].[Country], [t2].[Phone], [t2].[Fax] FROM ( SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] LIKE @p0 UNION ALL SELECT [t1].[CustomerID], [t1].[CompanyName], [t1].[ContactName], [t1].[ContactTitle], [t1].[Address], [t1].[City], [t1].[Region], [t1].[PostalCode], [t1].[Country], [t1].[Phone], [t1].[Fax] FROM [dbo].[Customers] AS [t1] WHERE [t1].[ContactName] LIKE @p1 ) AS [t2] ) AS [t3] ORDER BY [t3].[ContactName] -- @p0: Input String (Size = 3; Prec = 0; Scale = 0) [%A%] -- @p1: Input String (Size = 2; Prec = 0; Scale = 0) [A%] 取相交项 描述:查询城市是A打头的顾客和城市包含A的顾客的交集，并按照顾客名字排 序 查询句法: var 取相交项 = (from c in ctx.Customers where c.City.Contains("A") select c).Intersect (from c in ctx.Customers where c.ContactName.StartsWith("A") select c).OrderBy(c => c.ContactName); 对应SQL: SELECT [t1].[CustomerID], [t1].[CompanyName], [t1].[ContactName], [t1].[ContactTitle], [t1].[Address], [t1].[City], [t1].[Region], [t1].[PostalCode], [t1].[Country], [t1].[Phone], [t1].[Fax] FROM ( SELECT DISTINCT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] ) AS [t1] WHERE (EXISTS( SELECT NULL AS [EMPTY] FROM [dbo].[Customers] AS [t2] WHERE ([t1].[CustomerID] = [t2].[CustomerID]) AND ([t2].[ContactName] LIKE @p0) )) AND ([t1].[City] LIKE @p1) ORDER BY [t1].[ContactName] -- @p0: Input String (Size = 2; Prec = 0; Scale = 0) [A%] -- @p1: Input String (Size = 3; Prec = 0; Scale = 0) [%A%] 排除相交项 描述:查询城市包含A的顾客并从中删除城市以A开头的顾客，并按照顾客名字排序 查询句法: var 排除相交项 = (from c in ctx.Customers where c.City.Contains("A") select c).Except (from c in ctx.Customers where c.ContactName.StartsWith("A") select c).OrderBy(c => c.ContactName); 对应SQL: SELECT [t1].[CustomerID], [t1].[CompanyName], [t1].[ContactName], [t1].[ContactTitle], [t1].[Address], [t1].[City], [t1].[Region], [t1].[PostalCode], [t1].[Country], [t1].[Phone], [t1].[Fax] FROM ( SELECT DISTINCT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] ) AS [t1] WHERE (NOT (EXISTS( SELECT NULL AS [EMPTY] FROM [dbo].[Customers] AS [t2] WHERE ([t1].[CustomerID] = [t2].[CustomerID]) AND ([t2].[ContactName] LIKE @p0) ))) AND ([t1].[City] LIKE @p1) ORDER BY [t1].[ContactName] -- @p0: Input String (Size = 2; Prec = 0; Scale = 0) [A%] -- @p1: Input String (Size = 3; Prec = 0; Scale = 0) [%A%] 子查询 描述:查询订单数超过5的顾客信息 查询句法: var 子查询 = from c in ctx.Customers where (from o in ctx.Orders group o by o.CustomerID into o where o.Count() > 5 select o.Key).Contains(c.CustomerID) select c; 对应SQL: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE EXISTS( SELECT NULL AS [EMPTY] FROM ( SELECT COUNT(*) AS [value], [t1].[CustomerID] FROM [dbo].[Orders] AS [t1] GROUP BY [t1].[CustomerID] ) AS [t2] WHERE ([t2].[CustomerID] = [t0].[CustomerID]) AND ([t2].[value] > @p0) ) -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [5] in操作 描述:查询指定城市中的客户 查询句法: var in操作 = from c in ctx.Customers where new string[] { "Brandenburg", "Cowes", "Stavern" }.Contains(c.City) select c; 对应SQL: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] IN (@p0, @p1, @p2) -- @p0: Input String (Size = 11; Prec = 0; Scale = 0) [Brandenburg] -- @p1: Input String (Size = 5; Prec = 0; Scale = 0) [Cowes] -- @p2: Input String (Size = 7; Prec = 0; Scale = 0) [Stavern] join 描述:内连接，没有分类的产品查询不到 查询句法: var innerjoin = from p in ctx.Products join c in ctx.Categories on p.CategoryID equals c.CategoryID select p.ProductName; 对应SQL: SELECT COUNT(*) AS [value] FROM [dbo].[Products] AS [t0] INNER JOIN [dbo].[Categories] AS [t1] ON [t0].[CategoryID] = ([t1].[CategoryID]) 描述:外连接，没有分类的产品也能查询到 查询句法: var leftjoin = from p in ctx.Products join c in ctx.Categories on p.CategoryID equals c.CategoryID into pro from x in pro.DefaultIfEmpty() select p.ProductName; 对应SQL: SELECT COUNT(*) AS [value] FROM [dbo].[Products] AS [t0] LEFT OUTER JOIN [dbo].[Categories] AS [t1] ON [t0].[CategoryID] = ([t1].[CategoryID]) 你可能会很奇怪，原先很复杂的SQL使用查询句法会很简单(比如按照条件分组)。但是原先觉得很好理解的SQL使用查询句法会觉得很复杂(比如连接查询)。其实，我们还可以通过其它方式进行连接操作，在以后说DataLoadOptions 类型的时候会再说。虽然Linq to sql已经非常智能了，但是对于非常复杂的查询还是建议通过存储过程实现，下次讲解如何调用存储过程。 Linq to Sql(四):存储过程 普通存储过程 首先在查询分析器运行下面的代码来创建一个存储过程: create proc sp_singleresultset as set nocount on select * from customers 然后打开IDE的服务器资源管理器，之前我们从表中拖动表到dbml设计视图，这次我们从存储过程中找到刚才创建的存储过程，然后拖动到设计视图。在方法面板中可以看到已经创建了一个sp_singleresultset的方法，如下图: 然后打开Northwind.designer.cs，可以找到下面的代码: [Function(Name="dbo.sp_singleresultset")] public ISingleResult sp_singleresultset() { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod()))); return ((ISingleResult)(result.ReturnValue)); } 我们可以发现，IDE为这个存储过程单独生成了返回结果集的实体定义，你可能会觉得很奇怪，IDE怎么知道这个存储过程将会返回哪些数据那,其实，在把存储过程拖拽入dbml设计视图的时候，IDE就执行了类似下面的命令: SET FMTONLY ON; exec Northwind.dbo.sp_singleresultset SET FMTONLY OFF; 这样就可以直接获取存储过程返回的元数据而无须执行存储过程。 其实我们存储过程返回的就是顾客表的数据，如果你觉得为存储过程单独设置结果集实体有些浪费的话可以在存储过程的属性窗口中调整返回类型从“自动生成的类型”到Customer，不过以后你只能通过删除方法面板中的存储过程，然后重新添加来还原到“自动生成的类型”。下面，我们可以写如下的Linq to object代码进行查询: var 单结果集存储过程 = from c in ctx.sp_singleresultset() where c.CustomerID.StartsWith("A") select c; 在这里确实是Linq to object的，因为查询句法不会被整句翻译成SQL，而是从存储过程的返回对象中再去对对象进行查询。SQL代码如下: EXEC @RETURN_VALUE = [dbo].[sp_singleresultset] -- @RETURN_VALUE: Output Int32 (Size = 0; Prec = 0; Scale = 0) [] 带参数的存储过程 创建如下存储过程: create proc [dbo].[sp_withparameter] @customerid nchar(5), @rowcount int output as set nocount on set @rowcount = (select count(*) from customers where customerid = @customerid) 使用同样的方法生成存储过程方法，然后使用下面的代码进行测试: int? rowcount = -1; ctx.sp_withparameter("", ref rowcount); Response.Write(rowcount); ctx.sp_withparameter("ALFKI", ref rowcount); Response.Write(rowcount); 结果输出了“01”。说明ID为“”的顾客数为0，而ID为“ALFKI”的顾客数为1。存储过程的输出参数被封装成了ref参数，对于C#语法来说非常合情合理。SQL代码如下: EXEC @RETURN_VALUE = [dbo].[sp_withparameter] @customerid = @p0, @rowcount = @p1 OUTPUT -- @p0: Input StringFixedLength (Size = 5; Prec = 0; Scale = 0) [] -- @p1: InputOutput Int32 (Size = 0; Prec = 0; Scale = 0) [-1] -- @RETURN_VALUE: Output Int32 (Size = 0; Prec = 0; Scale = 0) [] 带返回值的存储过程 再来创建第三个存储过程: create proc [dbo].[sp_withreturnvalue] @customerid nchar(5) as set nocount on if exists (select 1 from customers where customerid = @customerid) return 101 else return 100 生成方法后，可以通过下面的代码进行测试: Response.Write(ctx.sp_withreturnvalue("")); Response.Write(ctx.sp_withreturnvalue("ALFKI")); 运行后程序输出“100101” 多结果集的存储过程 再来创建一个多结果集的存储过程: create proc [dbo].[sp_multiresultset] as set nocount on select * from customers select * from employees 找到生成的存储过程方法: [Function(Name="dbo.sp_multiresultset")] public ISingleResult sp_multiresultset() { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod()))); return ((ISingleResult)(result.ReturnValue)); } 由于现在的VS2008会把多结果集存储过程识别为单结果集存储过程(只 认识第一个结果集)，我们只能对存储过程方法多小动手术，修改为: [Function(Name="dbo.sp_multiresultset")] [ResultType(typeof(Customer))] [ResultType(typeof(Employee))] public IMultipleResults sp_multiresultset() { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod()))); return (IMultipleResults)(result.ReturnValue); } 然后使用下面的代码测试: var 多结果集存储过程 = ctx.sp_multiresultset(); var Customers = 多结果集存储过程.GetResult(); var Employees = 多结果集存储过程.GetResult(); GridView1.DataSource = from emp in Employees where emp.FirstName.Contains("A") select emp; GridView1.DataBind(); GridView2.DataSource = from c in Customers where c.CustomerID.StartsWith("A") select c; GridView2.DataBind(); 使用存储过程新增数据 存储过程除了可以直接调用之外，还可以用于实体的增删改操作。还记得在《一步一步学Linq to sql(三):增删改》中创建的留言簿程序吗,下面我们就来改造这个程序，使用存储过程而不是系统生成的SQL实现实体增删改。首先，我们创建下面的存储过程 create proc sendmessage @username varchar(50), @message varchar(500) as insert into tbguestbook (id,username,posttime,[message],isreplied,reply) values (newid(),@username,getdate(),@message,0,'') 然后，打开留言簿dbml，把存储过程从服务器资源管理器拖拽到设计视图上。右键点击tbGuestBook实体类，选择配置行为。如下图，为插入操作选择刚才创建的存储过程方法，并进行参数匹配: 由于我们的存储过程只接受2个参数，相应修改以下创建留言的按钮处 理事件: protected void btn_SendMessage_Click(object sender, EventArgs e) { tbGuestBook gb = new tbGuestBook(); gb.UserName = tb_UserName.Text; gb.Message = tb_Message.Text; ctx.tbGuestBooks.Add(gb); ctx.SubmitChanges(); SetBind(); } 运行程序后可以发现，在提交修改的时候调用了下面的SQL: EXEC @RETURN_VALUE = [dbo].[sendmessage] @username = @p0, @message = @p1 -- @p0: Input AnsiString (Size = 5; Prec = 0; Scale = 0) [zhuye] -- @p1: Input AnsiString (Size = 11; Prec = 0; Scale = 0) [new message] -- @RETURN_VALUE: Output Int32 (Size = 0; Prec = 0; Scale = 0) [] 使用存储过程删除数据 创建如下存储过程: create proc delmessage @id uniqueidentifier as delete tbguestbook where id=@id 按照前面的步骤生成存储过程方法，并为删除操作执行这个存储过程方法。在选择参数的时候我们可以看到，ID分当前值和原始值，我们选择当前值即可，如下图: 无须改动任何逻辑代码，进行删除留言操作后可以跟踪到下面的SQL: EXEC @RETURN_VALUE = [dbo].[delmessage] @id = @p0 -- @p0: Input Guid (Size = 0; Prec = 0; Scale = 0) [9e3c5ee3-2575-458e-899d-4b0bf73e0849] -- @RETURN_VALUE: Output Int32 (Size = 0; Prec = 0; Scale = 0) [] 使用存储过程更改数据 创建如下存储过程: create proc replymessage @id uniqueidentifier, @reply varchar(500) as update tbguestbook set reply=@reply,isreplied=1 where id=@id 由于更新的时候并不会更新主键，所以我们可以为两个参数都指定当前值。回复留言后可以跟踪到下面的SQL: EXEC @RETURN_VALUE = [dbo].[replymessage] @id = @p0, @reply = @p1 -- @p0: Input Guid (Size = 0; Prec = 0; Scale = 0) [67a69d0f-a88b-4b22-8939-fed021eb1cb5] -- @p1: Input AnsiString (Size = 6; Prec = 0; Scale = 0) [464456] -- @RETURN_VALUE: Output Int32 (Size = 0; Prec = 0; Scale = 0) [] 假设有这样一种应用，我们需要修改留言簿中不合法的用户名: create proc modiusername @oldusername varchar(50), @newusername varchar(50) as update tbguestbook set username=@newusername where username = @oldusername 有个网友起名叫“admin”，我们要把所有这个名字修改为“notadmin”。那么，可以如下图设置update操作: 然后运行下面的测试代码: var messages = from gb in ctx.tbGuestBooks select gb; foreach (var gb in messages) { if(gb.UserName == "admin") gb.UserName = "notadmin"; } 运行程序后能跟踪到下面的SQL: SELECT [t0].[ID], [t0].[UserName], [t0].[PostTime], [t0].[Message], [t0].[IsReplied], [t0].[Reply] FROM [dbo].[tbGuestBook] AS [t0] EXEC @RETURN_VALUE = [dbo].[modiusername] @oldusername = @p0, @newusername = @p1 -- @p0: Input AnsiString (Size = 5; Prec = 0; Scale = 0) [admin] -- @p1: Input AnsiString (Size = 8; Prec = 0; Scale = 0) [notadmin] -- @RETURN_VALUE: Output Int32 (Size = 0; Prec = 0; Scale = 0) [] 到这里，你应该能明白当前值和原始值的含义了吧。 Linq to Sql(五):探究特性 延迟执行 IQueryable query = from c in ctx.Customers select c; 这样的查询句法不会导致语句立即执行，它仅仅是一个描述，对应一个SQL。仅仅在需要使用的时候才会执行语句，比如: IQueryable query = from c in ctx.Customers select c; foreach (Customer c in query) Response.Write(c.CustomerID); 如果你执行两次foreach操作，将会捕获到两次SQL语句的执行: IQueryable query = from c in ctx.Customers select c; foreach (Customer c in query) Response.Write(c.CustomerID); foreach (Customer c in query) Response.Write(c.ContactName); 对应SQL: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] 对于这样的需求，建议你先使用ToList()等方法把查询结果先进行保 存，然后再对集合进行查询: IEnumerable customers = (from c in ctx.Customers select c).ToList(); foreach (Customer c in customers) Response.Write(c.CustomerID); foreach (Customer c in customers) Response.Write(c.ContactName); 延迟执行的优点在于我们可以像拼接SQL那样拼接查询句法，然后再执 行: var query = from c in ctx.Customers select c; var newquery = (from c in query select c).OrderBy(c => c.CustomerID); DataLoadOptions var products = from p in ctx.Products select p; foreach (var p in products) { if (p.UnitPrice > 10) ShowDetail(p.Order_Details); } private void ShowDetail(EntitySet orderdetails) {} 由于ShowDetail方法并没有使用到订单详细信息，所以这个操作只会执 行下面的SQL: SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID], [t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder], [t0].[ReorderLevel], [t0].[Discontinued] FROM [dbo].[Products] AS [t0] 现在修改一下ShowDetail方法: private void ShowDetail(EntitySet orderdetails) { foreach (var o in orderdetails) { Response.Write(o.Quantity + "
    "); } } 你会发现Linq to sql对每个价格大于10的产品都根据产品号进行了一 次查询: SELECT [t0].[OrderID], [t0].[ProductID], [t0].[UnitPrice], [t0].[Quantity], [t0].[Discount] FROM [dbo].[Order Details] AS [t0] WHERE [t0].[ProductID] = @p0 -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [1] 这样的语句查询了N次。这样的查询不是很合理，我们可以通过设置 DataContext的DataLoadOption，来指示 DataContext再加载产品信息的同时 把对应的产品订单信息一起加载: DataLoadOptions options = new DataLoadOptions(); options.LoadWith(p => p.Order_Details); ctx.LoadOptions = options; var products = from p in ctx.Products select p; 。。。。。。。。 再执行先前的查询会发现Linq to sql进行了左连接: SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID], [t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder], [t0].[ReorderLevel], [t0].[Discontinued], [t1].[OrderID], [t1].[ProductID] AS [ProductID2], [t1].[UnitPrice] AS [UnitPrice2], [t1].[Quantity], [t1].[Discount], ( SELECT COUNT(*) FROM [dbo].[Order Details] AS [t2] WHERE [t2].[ProductID] = [t0].[ProductID] ) AS [count] FROM [dbo].[Products] AS [t0] LEFT OUTER JOIN [dbo].[Order Details] AS [t1] ON [t1].[ProductID] = [t0].[ProductID] ORDER BY [t0].[ProductID], [t1].[OrderID] 那么，我们怎么限制订单详细表的加载条件那, DataLoadOptions options = new DataLoadOptions(); options.LoadWith(p => p.Order_Details); options.AssociateWith(p => p.Order_Details.Where(od => od.Quantity > 80)); ctx.LoadOptions = options; var products = from p in ctx.Products select p; 这样，就只会有数量大于80的订单详细信息会和产品一起加载: SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID], [t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder], [t0].[ReorderLevel], [t0].[Discontinued], [t1].[OrderID], [t1].[ProductID] AS [ProductID2], [t1].[UnitPrice] AS [UnitPrice2], [t1].[Quantity], [t1].[Discount], ( SELECT COUNT(*) FROM [dbo].[Order Details] AS [t2] WHERE ([t2].[Quantity] > @p0) AND ([t2].[ProductID] = [t0].[ProductID]) ) AS [count] FROM [dbo].[Products] AS [t0] LEFT OUTER JOIN [dbo].[Order Details] AS [t1] ON ([t1].[Quantity] > @p0) AND ([t1].[ProductID] = [t0].[ProductID]) ORDER BY [t0].[ProductID], [t1].[OrderID] -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [80] DataLoadOptions限制 Linq to sql对DataLoadOptions的使用是有限制的，它只支持1个1对多的关系。一个顾客可能有多个订单，一个订单可能有多个详细订单: DataLoadOptions options = new DataLoadOptions(); options.LoadWith(c => c.Orders); options.LoadWith(o => o.Order_Details); ctx.LoadOptions = options; IEnumerable customers = ctx.Customers.ToList(); 这样的语句执行后会导致下面的SQL执行N次(参数不同): SELECT [t0].[OrderID], [t0].[CustomerID], [t0].[EmployeeID], [t0].[OrderDate], [t0].[RequiredDate], [t0].[ShippedDate], [t0].[ShipVia], [t0].[Freight], [t0].[ShipName], [t0].[ShipAddress], [t0].[ShipCity], [t0].[ShipRegion], [t0].[ShipPostalCode], [t0].[ShipCountry], [t1].[OrderID] AS [OrderID2], [t1].[ProductID], [t1].[UnitPrice], [t1].[Quantity], [t1].[Discount], ( SELECT COUNT(*) FROM [dbo].[Order Details] AS [t2] WHERE [t2].[OrderID] = [t0].[OrderID] ) AS [count] FROM [dbo].[Orders] AS [t0] LEFT OUTER JOIN [dbo].[Order Details] AS [t1] ON [t1].[OrderID] = [t0].[OrderID] WHERE [t0].[CustomerID] = @x1 ORDER BY [t0].[OrderID], [t1].[ProductID] -- @x1: Input StringFixedLength (Size = 5; Prec = 0; Scale = 0) [ALFKI] 而对于多对1的关系，Linq to sql对于DataLoadOptions没有限制: DataLoadOptions options = new DataLoadOptions(); options.LoadWith(c => c.Category); options.LoadWith(c => c.Order_Details); options.LoadWith(o => o.Order); ctx.LoadOptions = options; IEnumerable products = ctx.Products.ToList(); 由于多个产品对应1个分类，多个详细订单对应1个订单，只有产品和 详细订单才是多对1的关系，所以也只会有1次SQL(不过这样的操作还是少执 行为妙，消耗太大了): SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID], [t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder], [t0].[ReorderLevel], [t0].[Discontinued], [t3].[OrderID], [t3].[ProductID] AS [ProductID2], [t3].[UnitPrice] AS [UnitPrice2], [t3].[Quantity], [t3].[Discount], [t4].[OrderID] AS [OrderID2], [t4].[CustomerID], [t4].[EmployeeID], [t4].[OrderDate], [t4].[RequiredDate], [t4].[ShippedDate], [t4].[ShipVia], [t4].[Freight], [t4].[ShipName], [t4].[ShipAddress], [t4].[ShipCity], [t4].[ShipRegion], [t4].[ShipPostalCode], [t4].[ShipCountry], ( SELECT COUNT(*) FROM [dbo].[Order Details] AS [t5] INNER JOIN [dbo].[Orders] AS [t6] ON [t6].[OrderID] = [t5].[OrderID] WHERE [t5].[ProductID] = [t0].[ProductID] ) AS [count], [t2].[test], [t2].[CategoryID] AS [CategoryID2], [t2].[CategoryName], [t2].[Description], [t2].[Picture] FROM [dbo].[Products] AS [t0] LEFT OUTER JOIN ( SELECT 1 AS [test], [t1].[CategoryID], [t1].[CategoryName], [t1].[Description], [t1].[Picture] FROM [dbo].[Categories] AS [t1] ) AS [t2] ON [t2].[CategoryID] = [t0].[CategoryID] LEFT OUTER JOIN ([dbo].[Order Details] AS [t3] INNER JOIN [dbo].[Orders] AS [t4] ON [t4].[OrderID] = [t3].[OrderID]) ON [t3].[ProductID] = [t0].[ProductID] ORDER BY [t0].[ProductID], [t2].[CategoryID], [t3].[OrderID] 主键缓存 Linq to sql对查询过的对象进行缓存，之后的如果只根据主键查询一 条记录的话会直接从缓存中读取。比如下面的代码: Customer c1 = ctx.Customers.Single(customer => customer.CustomerID == "ANATR"); c1.ContactName = "zhuye"; Customer c2 = ctx.Customers.Single(customer => customer.CustomerID == "ANATR"); Response.Write(c2.ContactName); 执行后只会产生一条SQL: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE [t0].[CustomerID] = @p0 -- @p0: Input String (Size = 5; Prec = 0; Scale = 0) [ANATR] 由于没有提交修改，所以数据库中的记录还是没有更新。由于这个特性，我们在使用存储过程作为实体更新方法的时候就要当心了，存储过程书写错误，即使你提交了修改也很可能导致缓存中的数据和数据库中的数据不一致，引起不必要的麻烦。 DataContext隔离 有的时候我们会把对象从外部传入DataContext，要求它更新，由于不同的DataContext是相对独立的。由于新的DataContext中还没有获取实体，我们只能通过附加方式更新数据。 首先把Customer表的主键字段加上IsVersion标识: [Column(Storage="_CustomerID", DbType="NChar(5) NOT NULL", CanBeNull=false, IsPrimaryKey=true, IsVersion = true)] 运行下面的测试代码: Customer c = new Customer { CustomerID = "ALFKI", ContactName = "zhuye", CompanyName = "1111" }; ctx.Customers.Attach(c, true); ctx.SubmitChanges(); 会捕捉到下面的SQL语句: UPDATE [dbo].[Customers] SET [CompanyName] = @p2, [ContactName] = @p3, [ContactTitle] = @p4, [Address] = @p5, [City] = @p6, [Region] = @p7, [PostalCode] = @p8, [Country] = @p9, [Phone] = @p10, [Fax] = @p11 WHERE ([CustomerID] = @p0) AND ([CustomerID] = @p1) -- @p0: Input StringFixedLength (Size = 5; Prec = 0; Scale = 0) [ALFKI] -- @p1: Input String (Size = 5; Prec = 0; Scale = 0) [ALFKI] -- @p2: Input String (Size = 4; Prec = 0; Scale = 0) [1111] -- @p3: Input String (Size = 5; Prec = 0; Scale = 0) [zhuye] -- @p4: Input String (Size = 0; Prec = 0; Scale = 0) [] -- @p5: Input String (Size = 0; Prec = 0; Scale = 0) [] -- @p6: Input String (Size = 0; Prec = 0; Scale = 0) [] -- @p7: Input String (Size = 0; Prec = 0; Scale = 0) [] -- @p8: Input String (Size = 0; Prec = 0; Scale = 0) [] -- @p9: Input String (Size = 0; Prec = 0; Scale = 0) [] -- @p10: Input String (Size = 0; Prec = 0; Scale = 0) [] -- @p11: Input String (Size = 0; Prec = 0; Scale = 0) [] Linq to Sql(六):并发与事务 检测并发 首先使用下面的SQL语句查询数据库的产品表: select * from products where categoryid=1 查询结果如下图: 为了看起来清晰，我已经事先把所有分类为1产品的价格和库存修改为相同值了。然后执行下面的程序: var query = from p in ctx.Products where p.CategoryID == 1 select p; foreach (var p in query) p.UnitsInStock = Convert.ToInt16(p.UnitsInStock - 1); ctx.SubmitChanges(); // 在这里设断点 我们使用调试方式启动，由于设置了断点，程序并没有进行更新操作。此时，我们在数据库中运行下面的语句: update products set unitsinstock = unitsinstock -2, unitprice= unitprice + 1 where categoryid = 1 然 后在继续程序，会得到修改并发(乐观并发冲突)的异常，提示要修改的行不存在或者已经被改动。当客户端提交的修改对象自读取之后已经在数据库中发生改动， 就产生了修改并发。解决并发的包括两步，一是查明哪些对象发生并发，二是解决并发。如果你仅仅是希望更新时不考虑并发的话可以关闭相关列的更新验证，这样 在这些列上发生并发就不会出现异常: [Column(Storage="_UnitsInStock", DbType="SmallInt", UpdateCheck = UpdateCheck.Never)] [Column(Storage="_UnitPrice", DbType="Money", UpdateCheck = UpdateCheck.Never)] 为这两列标注不需要进行更新检测。假设现在产品价格和库存分别是27和32。那么，我们启动程序(设置端点)，然后运行UPDATE语句，把价格+1，库存-2，然后价格和库存分别为28和30了，继续程序可以发现价格和库存分别是28和31。价格+1是之前更新的功劳，库存最终是-1是我们程序之后更新的功劳。当在同一个字段上(库存)发生并发冲突的时候，默认是最后的那次更新获胜。 解决并发 如果你希望自己处理并发的话可以把前面对列的定义修改先改回来，看下面的例子: var query = from p in ctx.Products where p.CategoryID == 1 select p; foreach (var p in query) p.UnitsInStock = Convert.ToInt16(p.UnitsInStock - 1); try { ctx.SubmitChanges(ConflictMode.ContinueOnConflict); } catch (ChangeConflictException) { foreach (ObjectChangeConflict cc in ctx.ChangeConflicts) { Product p = (Product)cc.Object; Response.Write(p.ProductID + "
    "); cc.Resolve(RefreshMode.OverwriteCurrentValues); // 放弃当前更新，所有更新以原先更新为准 } } ctx.SubmitChanges(); 首先可以看到，我们使用try{}catch{}来捕捉并发冲突的异常。在SubmitChanges的时候，我们选择了ConflictMode.ContinueOnConflict选项。也就是说遇到并发了还是继续。在catch{}中，我们从ChangeConflicts中获取了并发的对象，然后经过类型转化后输出了产品ID，然后选择的解决 方案 气瓶 现场处置方案 .pdf气瓶 现场处置方案 .doc见习基地管理方案.doc关于群访事件的化解方案建筑工地扬尘治理专项方案下载 是RefreshMode.OverwriteCurrentValues。也就是说，放弃当前的更新，所有更新以原先更新为准。 我们来测试一下，假设现在产品价格和库存分别是27和32。那么，我们启动程序(在ctx.SubmitChanges(ConflictMode.ContinueOnConflict)这里设置端点)，然后运行UPDATE语句，把价格+1，库存-2，然后价格和库存分别为28和30了，继续程序可以发现价格和库存分别是28和30。之前SQL语句库存-2生效了，而我们程序的更新(库存-1)被放弃了。在页面上也显示了所有 分类为1的产品ID(因为我们之前的SQL语句是对所有分类为1的产品都进行修改的)。 然后，我们来修改一下解决并发的方式: cc.Resolve(RefreshMode.KeepCurrentValues); // 放弃原先更新，所有更新以当前更新为准 来测试一下，假设现在产品价格和库存分别是27和32。那么，我们启动程序(在ctx.SubmitChanges(ConflictMode.ContinueOnConflict)这里设置端点)，然后运行UPDATE语句，把价格+1，库存-2，然后价格和库存分别为28和30了，继续程序可以发现价格和库存分别是27和31。产品价格没有变化，库存-1了，都是我们程序的功劳，SQL语句的更新被放弃了。 然后，我们再来修改一下解决并发的方式: cc.Resolve(RefreshMode.KeepChanges); // 原先更新有效，冲突字段以当前更新为准 来测试一下，假设现在产品价格和库存分别是27和32。那么，我们启动程序(在ctx.SubmitChanges(ConflictMode.ContinueOnConflict)这里设置端点)，然后运行UPDATE语句，把价格+1，库存-2，然后价格和库存分别为28和30了，继续程序可以发现价格和库存分别是28和31。这就是默认方式，在保持原先更新的基础上，对于发生冲突的字段以最后更新为准。 我们甚至还可以针对不同的字段进行不同的处理策略: foreach (ObjectChangeConflict cc in ctx.ChangeConflicts) { Product p = (Product)cc.Object; foreach (MemberChangeConflict mc in cc.MemberConflicts) { string currVal = mc.CurrentValue.ToString(); string origVal = mc.OriginalValue.ToString(); string databaseVal = mc.DatabaseValue.ToString(); MemberInfo mi = mc.Member; string memberName = mi.Name; Response.Write(p.ProductID + " " + mi.Name + " " + currVal + " " + origVal +" "+ databaseVal + "
    "); if (memberName == "UnitsInStock") mc.Resolve(RefreshMode.KeepCurrentValues); // 放弃原先更新，所有更新以当前更新为准 else if (memberName == "UnitPrice") mc.Resolve(RefreshMode.OverwriteCurrentValues); // 放弃当前更新，所有更新以原先更新为准 else mc.Resolve(RefreshMode.KeepChanges); // 原先更新有效，冲突字段以当前更新为准 } } 比如上述代码就对库存字段作放弃原先更新处理，对价格字段作放弃当前更新处理。我们来测试一下，假设现在产品价格和库存分别是27和32。那么，我们启动程序(在ctx.SubmitChanges(ConflictMode.ContinueOnConflict)这里设置端点)，然后运行UPDATE语句，把价格+1，库存-2，然后价格和库存分别为28和30了，继续程序可以发现价格和库存分别为28和31了。说明对价格的处理确实保留了原先的更新，对库存的处理保留了当前的更新。页面上显示的结果如下图: 最后，我们把提交语句修改为: ctx.SubmitChanges(ConflictMode.FailOnFirstConflict); 表示第一次发生冲突的时候就不再继续了，然后并且去除最后的ctx.SubmitChanges();语句。来测试一下，在执行了SQL后再继续程序可以发现界面上只输出了数字1，说明在第一条记录失败后，后续的并发冲突就不再处理了。 事务处理 Linq to sql在提交更新的时候默认会创建事务，一部分修改发生错误的话其它修改也不会生效: ctx.Customers.Add(new Customer { CustomerID = "abcdf", CompanyName = "zhuye" }); ctx.Customers.Add(new Customer { CustomerID = "abcde", CompanyName = "zhuye" }); ctx.SubmitChanges(); 假设数据库中已经存在顾客ID为“abcde”的记录，那么第二次插入操作失败将会导致第一次的插入操作失效。执行程序后会得到一个异常，查询数据库发现“abcdf”这个顾客也没有插入到数据库中。 如果每次更新后直接提交修改，那么我们可以使用下面的方式做事务: if (ctx.Connection != null) ctx.Connection.Open(); DbTransaction tran = ctx.Connection.BeginTransaction(); ctx.Transaction = tran; try { CreateCustomer(new Customer { CustomerID = "abcdf", CompanyName = "zhuye" }); CreateCustomer(new Customer { CustomerID = "abcde", CompanyName = "zhuye" }); tran.Commit(); } catch { tran.Rollback(); } private void CreateCustomer(Customer c) { ctx.Customers.Add(c); ctx.SubmitChanges(); } 运行程序后发现增加顾客abcdf的操作并没有成功。或者，我们还可以通过TransactionScope实现事务: using (TransactionScope scope = new TransactionScope()) { CreateCustomer(new Customer { CustomerID = "abcdf", CompanyName = "zhuye" }); CreateCustomer(new Customer { CustomerID = "abcde", CompanyName = "zhuye" }); scope.Complete(); } Linq to Sql(七):继承与关系 论坛表结构 为了演示继承与关系，我们创建一个论坛数据库，在数据库中创建三个表: 1、 论坛版块分类表 dbo.Categories: 字段名 字段类型 可空 备注 CategoryID int not null identity/主键 CategoryName varchar(50) not null 2、 论坛版块表 dbo.Boards: 字段名 字段类型 可空 备注 BoardID int not null identity/主键 BoardName varchar(50) not null BoardCategory int not null 对应论坛版块分 类表的 CategoryID 3、 论坛主 题 快递公司问题件快递公司问题件货款处理关于圆的周长面积重点题型关于解方程组的题及答案关于南海问题 表 dbo.Topics: 字段名 字段类型 可空 备注 TopicID int not null identity/主键 TopicTitle varchar(50) not null TopicContent varchar(max) not null ParentTopic int null 如果帖子是主题 贴这个字段为 null，否则就是所 属主题id TopicType tinyint not null 0 – 主题贴 1 – 回复帖 实体继承的定义 Linq to sql支持实体的单表继承，也就是基类和派生类都存储在一个表中。对于论坛来说，帖子有两种，一种是主题贴，一种是回复帖。那么，我们就先定义帖子基类: [Table(Name = "Topics")] public class Topic { [Column(Name = "TopicID", DbType = "int identity", IsPrimaryKey = true, IsDbGenerated = true, CanBeNull = false)] public int TopicID { get; set; } [Column(Name = "TopicType", DbType = "tinyint", CanBeNull = false)] public int TopicType { get; set; } [Column(Name = "TopicTitle", DbType = "varchar(50)", CanBeNull = false)] public string TopicTitle { get; set; } [Column(Name = "TopicContent", DbType = "varchar(max)", CanBeNull = false)] public string TopicContent { get; set; } } 这些实体的定义大家应该很熟悉了。下面，我们再来定义两个实体继承帖子基类，分别是主题贴和回复贴: public class NewTopic : Topic { public NewTopic() { base.TopicType = 0; } } public class Reply : Topic { public Reply() { base.TopicType = 1; } [Column(Name = "ParentTopic", DbType = "int", CanBeNull = false)] public int ParentTopic { get; set; } } 对于主题贴，在数据库中的TopicType就保存为0，而对于回复贴就保存为1。回复贴还有一个相关字段就是回复所属主题贴的TopicID。那么，我们 怎么告知Linq to sql在TopicType为0的时候识别为NewTopic，而1则识别为Reply那,只需稍微修改一下前面的Topic实体定义: [Table(Name = "Topics")] [InheritanceMapping(Code = 0, Type = typeof(NewTopic), IsDefault = true)] [InheritanceMapping(Code = 1, Type = typeof(Reply))] public class Topic { [Column(Name = "TopicID", DbType = "int identity", IsPrimaryKey = true, IsDbGenerated = true, CanBeNull = false)] public int TopicID { get; set; } [Column(Name = "TopicType", DbType = "tinyint", CanBeNull = false, IsDiscriminator = true)] public int TopicType { get; set; } [Column(Name = "TopicTitle", DbType = "varchar(50)", CanBeNull = false)] public string TopicTitle { get; set; } [Column(Name = "TopicContent", DbType = "varchar(max)", CanBeNull = false)] public string TopicContent { get; set; } } 为类加了InheritanceMapping特性定义，0的时候类型就是NewTopic，1的时候就是Reply。并且为TopicType字段上的特性中加了IsDiscriminator = true，告知Linq to sql这个字段就是用于分类的字段。 实体继承的使用 定义好继承的实体之后，我们就可以使用了。先是自定义一个DataContext吧: public partial class BBSContext : DataContext { public Table BoardCategories; public Table Boards; public Table Topics; public BBSContext(string connection) : base(connection) { } } 然后，我们来测试一下Linq to sql是否能根据TopicType识别派生类: BBSContext ctx = new BBSContext("server=xxx;database=BBS;uid=xxx;pwd=xxx"); var query = from t in ctx.Topics select t; foreach (Topic topic in query) { if (topic is NewTopic) { NewTopic newtopic = topic as NewTopic; Response.Write("标题:" + newtopic.TopicTitle + " 类型:" + newtopic.TopicType + "
    "); } else if (topic is Reply) { Reply reply = topic as Reply; Response.Write("标题:" + reply.TopicTitle + " 类型:" + reply.TopicType + " 隶属主题:" + reply.ParentTopic + "
    "); } } 然后我们往Topics表中加一些数据，如下图: 启动程序得到如下测试结果: 当然，你也可以在查询句法中直接查询派生实体: IEnumerable newtopiclist = (from t in ctx.Topics.OfType() select t).ToList(); newtopics.DataSource = newtopiclist; IEnumerable replylist = (from t in ctx.Topics.OfType() select t).ToList(); replies.DataSource = replylist; Page.DataBind(); newtopic和replies是两个GridView控件，执行效果如下图: 再来看看如何进行增删操作: NewTopic nt = new NewTopic() { TopicTitle = "还是新主题", TopicContent = "还是新主题" }; Reply rpl = new Reply() { TopicTitle = "还是新回复", TopicContent = "还是新回复", ParentTopic = 4 }; ctx.Topics.Add(nt); ctx.Topics.Add(rpl); ctx.SubmitChanges(); rpl = ctx.Topics.OfType().Single(reply => reply.TopicID == 8); ctx.Topics.Remove(rpl); ctx.SubmitChanges(); 实体关系的定义 比如我们的论坛分类表和论坛版块表之间就有关系，这种关系是1对多的关系。也就是说一个论坛分类可能有多个论坛版块，这是很常见的。定义实体关系的优势在于，我们无须显式作连接操作就能处理关系表的条件。 首先来看看分类表的定义: [Table(Name = "Categories")] public class BoardCategory { [Column(Name = "CategoryID", DbType = "int identity", IsPrimaryKey = true, IsDbGenerated = true, CanBeNull = false)] public int CategoryID { get; set; } [Column(Name = "CategoryName", DbType = "varchar(50)", CanBeNull = false)] public string CategoryName { get; set; } private EntitySet _Boards; [Association(OtherKey = "BoardCategory", Storage = "_Boards")] public EntitySet Boards { get { return this._Boards; } set { this._Boards.Assign(value); } } public BoardCategory() { this._Boards = new EntitySet(); } } CategoryID和CategoryName的映射没有什么不同，只是我们还增加了一个Boards属性，它返回的是Board实体集。通过特性，我们定义了关系外键为BoardCategory(Board表的一个字段)。然后来看看1对多，多端版块表的实体: [Table(Name = "Boards")] public class Board { [Column(Name = "BoardID", DbType = "int identity", IsPrimaryKey = true, IsDbGenerated = true, CanBeNull = false)] public int BoardID { get; set; } [Column(Name = "BoardName", DbType = "varchar(50)", CanBeNull = false)] public string BoardName { get; set; } [Column(Name = "BoardCategory", DbType = "int", CanBeNull = false)] public int BoardCategory { get; set; } private EntityRef _Category; [Association(ThisKey = "BoardCategory", Storage = "_Category")] public BoardCategory Category { get { return this._Category.Entity; } set { this._Category.Entity = value; value.Boards.Add(this); } } } 在这里我们需要关联分类，设置了Category属性使用BoardCategory 字段和分类表关联。 实体关系的使用 好了，现在我们就可以在查询句法中直接关联表了(数据库中不一定要设置表的外键关系): Response.Write("-------------查询分类为1的版块-------------
    "); var query1 = from b in ctx.Boards where b.Category.CategoryID == 1 select b; foreach (Board b in query1) Response.Write(b.BoardID + " " + b.BoardName + "
    "); Response.Write("-------------查询版块大于2个的分类-------------
    "); var query2 = from c in ctx.BoardCategories where c.Boards.Count > 2 select c; foreach (BoardCategory c in query2) Response.Write(c.CategoryID + " " + c.CategoryName + " " + c.Boards.Count + "
    "); 在数据库中加一些测试数据，如下图: 运行程序后得到下图的结果: 我想定义实体关系的方便我不需要再用语言形容了吧。执行上述的程序会导致下面SQL的执行: SELECT [t0].[BoardID], [t0].[BoardName], [t0].[BoardCategory] FROM [Boards] AS [t0] INNER JOIN [Categories] AS [t1] ON [t1].[CategoryID] = [t0].[BoardCategory] WHERE [t1].[CategoryID] = @p0 -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [1] SELECT [t0].[CategoryID], [t0].[CategoryName] FROM [Categories] AS [t0] WHERE (( SELECT COUNT(*) FROM [Boards] AS [t1] WHERE [t1].[BoardCategory] = [t0].[CategoryID] )) > @p0 -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [2] SELECT [t0].[BoardID], [t0].[BoardName], [t0].[BoardCategory] FROM [Boards] AS [t0] WHERE [t0].[BoardCategory] = @p0 -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [1] 可以看到，第二个查询并没有做外连接，还记得DataLoadOptions吗,我们可以要求Linq to sql在读取版块分类信息的时候也把版块信息一起加载: DataLoadOptions options = new DataLoadOptions(); options.LoadWith(c => c.Boards); ctx.LoadOptions = options; Response.Write("-------------查询版块大于2个的分类-------------
    "); var query2 = from c in ctx.BoardCategories where c.Boards.Count > 2 select c; foreach (BoardCategory c in query2) Response.Write(c.CategoryID + " " + c.CategoryName + " " + c.Boards.Count + "
    "); 查询经过改造后会得到下面的SQL: SELECT [t0].[CategoryID], [t0].[CategoryName], [t1].[BoardID], [t1].[BoardName], [t1].[BoardCategory], ( SELECT COUNT(*) FROM [Boards] AS [t3] WHERE [t3].[BoardCategory] = [t0].[CategoryID] ) AS [count] FROM [Categories] AS [t0] LEFT OUTER JOIN [Boards] AS [t1] ON [t1].[BoardCategory] = [t0].[CategoryID] WHERE (( SELECT COUNT(*) FROM [Boards] AS [t2] WHERE [t2].[BoardCategory] = [t0].[CategoryID] )) > @p0 ORDER BY [t0].[CategoryID], [t1].[BoardID] -- @p0: Input Int32 (Size = 0; Prec = 0; Scale = 0) [2] 在添加分类的时候，如果这个分类下还有新的版块，那么提交新增分类的时候版块也会新增: BoardCategory dbcat = new BoardCategory() { CategoryName = "Database" }; Board oracle = new Board() { BoardName = "Oracle", Category = dbcat}; ctx.BoardCategories.Add(dbcat); ctx.SubmitChanges(); 上述代码导致下面的SQL被执行: INSERT INTO [Categories]([CategoryName]) VALUES (@p0) SELECT [t0].[CategoryID] FROM [Categories] AS [t0] WHERE [t0].[CategoryID] = (SCOPE_IDENTITY()) -- @p0: Input AnsiString (Size = 8; Prec = 0; Scale = 0) [Database] INSERT INTO [Boards]([BoardName], [BoardCategory]) VALUES (@p0, @p1) SELECT [t0].[BoardID] FROM [Boards] AS [t0] WHERE [t0].[BoardID] = (SCOPE_IDENTITY()) -- @p0: Input AnsiString (Size = 6; Prec = 0; Scale = 0) [Oracle] -- @p1: Input Int32 (Size = 0; Prec = 0; Scale = 0) [23] Linq to sql(八):其它 外部映射文件 我们可以使用sqlmetal命令行工具来生成外部映射文件，使用方法如下: 1、开始菜单 ,》 VS2008 ,》VS工具 ,》VS2008命令行提示 2、输入命令: D:\Program Files\Microsoft Visual Studio 9.0\VC>sqlmetal /conn:server=xxx; database=Northwind;uid=xxx;pwd=xxx /map:c:\northwind.map /code:c:\northwind.cs 3、这样，我们就可以在C盘下得到一个xml映射文件和C#的实体类代码 4、把.cs文件添加到项目中来(放到App_Code目录)，然后使用下面的代码加载映射文件: String path = @"C:\Northwind.map"; XmlMappingSource xms = XmlMappingSource.FromXml(File.ReadAllText(path)); Northwind ctx = new Northwind("server=xxx;database=Northwind;uid=xxx;pwd=xxx", xms); 5、现在就可以照常进行其它工作了。使用sqlmetal可以很方便的同步数据库与实体和映射文件。每次修改数据库结构，从dbml设计器上删除表、存储过程然后再重新添加也是很麻烦的事情。 处理空值 var count = (from c in ctx.Customers where c.Region == null select c).Count(); Response.Write(count + "
    "); var query = from emp in ctx.Employees select emp.ReportsTo; foreach (Nullable r in query) { Response.Write(r.HasValue ? r.Value.ToString() + "
    " : "没有
    "); } 代码执行后捕获到下面的SQL被执行: SELECT COUNT(*) AS [value] FROM [dbo].[Customers] AS [t0] WHERE [t0].[Region] IS NULL SELECT [t0].[ReportsTo] FROM [dbo].[Employees] AS [t0] 已编译查询 对于一些在项目中经常被用到的查询可以封装成已编译查询，这样就能提高执行效率: static class Queries { public static Func> CustomersByCity = CompiledQuery.Compile((NorthwindDataContext ctx, string city) => from c in ctx.Customers where c.City == city select c); } 调用查询方式如下: GridView1.DataSource = Queries.CustomersByCity(ctx, "London"); GridView1.DataBind(); 获取一些信息 var query = from c in ctx.Customers select c; Response.Write("Provider类型:" + ctx.Mapping.ProviderType + "
    "); Response.Write("数据库:" + ctx.Mapping.DatabaseName + "
    "); Response.Write("表:" + ctx.Mapping.GetTable(typeof(Customer)).TableName + "
    "); Response.Write("表达式:" + query.Expression.ToString() + "
    "); Response.Write("sql:" + query.Provider.ToString() + "
    "); 上面的代码执行结果如下: Provider类型:System.Data.Linq.SqlClient.SqlProvider 数据库:Northwind 表:dbo.Customers 表达式:Table(Customer).Select(c => c) sql:SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] 撤销提交 var customer = ctx.Customers.Single(c => c.CustomerID == "AROUT"); customer.ContactName = "zhuye"; customer.Country = "Shanghai"; Response.Write(string.Format("Name:{0},Country:{1}
    ", customer.ContactName, customer.Country)); customer = ctx.Customers.GetOriginalEntityState(customer); Response.Write(string.Format("Name:{0},Country:{1}
    ", customer.ContactName, customer.Country)); 上面的代码执行效果如下: Name:zhuye,Country:Shanghai Name:Thomas Hardy,Country:UK 批量操作 下面的代码会导致提交N次DELETE操作: var query = from c in ctx.Customers select c; ctx.Customers.RemoveAll(query); ctx.SubmitChanges(); 应该使用sql语句进行批操作: string sql = String.Format("delete from {0}", ctx.Mapping.GetTable(typeof(Customer)).TableName); ctx.ExecuteCommand(sql); 对于批量更新操作也是同样道理。 LINQ体验(1)——Visual Studio 2008新特性 一、写本系列的目的 我平时利用课余零碎时间来学习ASP.NET3.5、LINQ、Silverlight、ASP.NET 3.5 Extensions等新东西，通过笔记形式来记录自己所学的历 程，也给大家一起学习Visual Studio 2008 和 .NET 3.5提供一个平台，为保证此系列的完整性，我打算先依次介绍一下C# 3.0新语言特性和 改进，然后从一条一条LINQ语句分析来贯穿LINQ的知识点。最后通过一个实例程序实战Linq to sql带来全新的编程体验。此系列比较长，欢迎大 家关注和对此系列提出建议。已经熟悉的朋友欢迎去博客园社区的 Web技术联盟小组，在 Web技术联盟小组的 TerryLee组长带领组员正在做一个基于ASP.NET 3.5和ASP.NET 3.5 Extensions的个人站点示例的开源项目Extended Personal Site Starter Kit。可以去参与这个有意义的项目。 本人刚刚学习就把自己学到的东西分享给大家吧～因本人水平有限，错误再所 难免，还请大家指出并谅解。 好了，让我们开始吧～ 二、Visual Studio 2008 和.NET 3.5总体认识 在2007年11月19日，微软发布了Visual Studio 2008 和.NET 3.5，具体见这里。 你可以在这里下载Visual Studio Team Suite 2008的90天免费试用版本。 .NET Framework 3.5总体框架图 VS 2008 & .NET 3.5框架图 通过这两张图相信大家对VS2008有了一点感性的认识了。下面正式开始了。 三、Visual Studio 2008的新特性 本篇是此系列的第一篇，还是从Visual Studio 2008的新特性开始吧～先总体认识一下Microsoft 花了3年时间开发出来这个新工具～ 在VS2008中包含成堆的新特性和新功能，这些全新的功能会大大的提高我们工作效率并且会减少我们的复杂程序。主要包括.NET Framework 对重定向的支持;ASP.NET AJAX和JavaScript智能客户端支持;全新的Web开发新体验:Web设计器提供了分割视图编辑、嵌套母板页、以及强大 的CSS编辑器集成;编程语言方面的改进和LINQ;浏览.NET Framework库源 码;智能部署ClickOnce;.NET Framework 3.5 增强功能;集成对 Office (VSTO)和Sharepoint 2007开发的支持;在Windows Server 2008, Windows Vista 和Microsoft Office 2007下最好的开发工 具集;单元测试功能，所有的Visual Studio专业版本都支持单元测试功能等等。 下面简单介绍一下: .NET Framework 对重定向的支持 使用Visual Studio 2008可以进行基于多个.net framework 版本的开发，Visual Studio 2008同时支持framework 2.0/3.0和3.5几个 版本。在不同的版本下它可以自动的框架特性工具箱，项目类型，引用，智能提示„„过滤功能。我们升级到Visual Studio 2008也非常简单。 ASP.NET AJAX和JavaScript智能客户端支持 ASP.NET AJAX成为.NET 3.5的一部分，除了包括ASP.NET AJAX 1.0的所有功能外，还集成了WebParts的UpdatePanel，与 and 这样的控件的ASP.NET AJAX 集成，WCF对JSON的支持，编写JavaScript提供了智能提示的功能。 全新的Web开发新体验 Web设计器提供了分割视图编辑、嵌套母板页、以及强大的CSS编辑器集成。 ASP.NET还提供了三个新的控件:、、 ， 这些控件对数据场景提供了非常好的支持，允许对输出的标识做完全的控制。 编程语言方面的改进和LINQ VS 2008中新的VB和C#编译器对这些语言做了显著的改进。两者都添加了对函数式编程概念的支持。 非常酷的LINQ(语言级集成查询)，我想这也是Visual Studio 2008的卖点。 浏览.NET Framework库源码 Visual Studio 2008有内置的调试器支持，自动按需调试进入代码(VS 2008可以自动为你下载适当的.NET框架库文件)。 LINQ体验(2)——C# 3.0新语言特性和改进(上篇) 在第一篇中，知道了Visual Studio 2008新特性，从这篇开始进入此系列的第二部分——介绍C# 3.0新语言特性和改进。 总体来说，Visual Studio 2008和.NET 3.5是建立在.NET2.0核心的基础之上，.NET2.0核心本身将不再变化(如果不了解.NET2.0的朋友，请参看MSDN或者一些经典的书籍)，C# 3.0新语言特性在.NET2.0基础上进行了改进，这些改进的功能可以大大简化我们编写程序。关于C# 3.0新 语言特性在博客园里的很多朋友都介绍了，我在这里简单介绍一下，记录 自己所学的东西，也为后面的LINQ打下基础。 C# 3.0新语言特性和改进包括: , 自动属性(Auto-Implemented Properties) , 隐含类型局部变量(Local Variable Type Inference) , 匿名类型(Anonymous Types) , 对象与集合初始化器(Object and Collection Initializers) , 扩展方法(Extension Methods) , Lambda表达式和Lambda表达式树 (Lambda Expression and Lambda Expression Trees) 自动属性(Auto-Implemented Properties) 自动属性可以避免原来这样我们手工声明一个私有成员变量以及编写 get/set逻辑，在VS2008中可以像下面这样编写一个类，编译器会自动地 生成私有变量和默认的get/set 操作。你也可以分别定义get和set的 “protected”等访问级别。 在.Net2.0框架下，我们可以这样写一个User类: public class User { private int _id; private string _name; private int _age; public int Id { get { return _id; } set { _id = value; } } public string Name { get { return _name; } set { _name = value; } } public int Age { get { return _age; } set { _age = value; } } } 现在，可以这样简化: public class User { public int Id { get; set; } public string Name { get; set; } public int Age { get; set; } } 像上面这样的空的get/set属性的话，它会自动为你在类中生成一个私有 成员变量，对这个变量实现一个公开的getter 和setter。我们可以使 用.NET开发环境所提供的ildasm.exe(IL代码反汇编器)工具来分析程 序集或者模块的内容。我就不贴图了。 隐含类型局部变量(Local Variable Type Inference) C#3.0引进了var这个新关键字，在声明局部变量时可用于替代原先的类型名，即当一个变量声明标识为var类型并且该范围域中没有var名称类型存在，那么这个声明就称为隐含类型局部变量。如下(等同于//后面的显式声明): var i = 5;//int var j = 23.56;//double var k = "C Sharp";//string var x;//错误 var y = null;//错误 var z = { 1, 2, 3 };//错误 在调试状态下，编译器解释如下 隐含类型局部变量要点 1. var为关键字，可以根据后面的初始化语句自动推断类型，这个类型 为强类型。 2. 初始化语句必须为表达式，不可以为空。且编译时可以推断类型。 一旦初始化之后，只可以存储这种类型。 3. var声明的仅限于局部变量，不可用于字段。亦可以用于for，foreach， using 等语句中。 4. 数组也可以作为隐含类型。 5. 初始化语句不能是一个自身的对象或者集合初始化器，但是他可以 是包含一个对象或者初始化器的一个new表达式。 6. 如果局部变量声明包含了多个声明符，其类型必须相同。 匿名类型(Anonymous Types) 匿名类型允许定义行内类型，无须显式定义类型。常和var配合使用来声明匿名类型。 var p1 = new { Id = 1, Name = "YJingLee", Age = 22 };//属性也不需要申明 var p2 = new { Id = 2, Name = "XieQing", Age = 25 }; p1 = p2;//p1,p2结构相同，可以互相赋值 在这里编译器会认为p1,p2相当于: public class SomeType { public int Id { get; set; } public string Name { get; set; } public int Age { get; set; } } 那么数组怎么定义呢,使用"new[]"关键字来声明数组，加上数组的初始值列表。像这样: var intArray = new[] { 2, 3, 5, 6 }; var strArray = new[] { "Hello", "World" }; var anonymousTypeArray = new[] { new { Name = "YJingLee", Age = 22 }, new { Name = "XieQing", Age = 25 } }; var a = intArray[0]; var b = strArray[0]; var c = anonymousTypeArray[1].Name; 匿名类型要点 1. 可以使用new关键字调用匿名初始化器创建一个匿名类型的对象。 2. 匿名类型直接继承自System. Object。 3. 匿名类型的成员是编译器根据初始化器推断而来的一些读写属性。 对象与集合初始化器(Object and Collection Initializers) 对象初始化器 (Object Initializers) : .NET2.0框架中的类型非常依赖于属性。当生成对象实例和使用新的类型时，在.Net2.0时候我们像这样写: User user = new User(); user.Id = 1; user.Name = "YJingLee"; user.Age = 22; 在VS2008中，编译器会自动地生成合适的属性setter代码，使得原来几行的属性赋值操作可以在一行完成。我们可以这样简化:像这样，对象初始化器由一系列成员对象组成，其对象必须初始化，用逗号间隔，使用{}封闭。 User user = new User { Id = 1, Name = "YJingLee", Age = 22 }; 又例如，我把二个人加到一个基于泛型的类型为User的List集合中: List user = new List{ new User{Id=1,Name="YJingLee",Age=22}, new User{Id=2,Name="XieQing",Age=25}, }; 如果有相同名字和类型的两个对象初始化器将会产生相同的实例，可以相互赋值。例如: User user = new User { Id = 1, Name = "YJingLee", Age = 22 }; User user2 = new User { Id = 2, Name = "XieQing", Age = 25 }; user = user2; 除了在初始化类时设置简单的属性值外，对象初始化器特性也允许我们设置更复杂的嵌套(nested)属性类型。例如我们可以在上面定义的User类型同时拥有一个属于Address类型的叫“Address”的属性: User user = new User { Id = 1, Name = "YJingLee", Age = 22, Address = new Address { City = "NanJing", Zip = 21000 } }; 集合初始化器(Collection Initializers): 集合初始化器由一系列集合对象组成，用逗号间隔，使用{}封闭。 集合初始化器可以简化把几个对象一起添加到一个集合，编译器会自动为你做集合插入操作。例如我把七个数加到一个基于泛型的类型为int的List集合中 List num = new List { 0, 1, 2, 6, 7, 8, 9 }; 对象与集合初始化器要点 1. 对象初始化器实际上利用了编译器对对象中对外可见的字段和属性 进行按序赋值。 2. 对象初始化器允许只给一部分属性赋值，包括internal访问级别 3. 对象初始化器可以结合构造函数一起使用，并且构造函数初始化先 于对象初始化器执行。 4. 集合初始化器会对初始化器中的元素进行按序调用 ICollection.Add(T)方法。 5. 注意对象初始化器和集合初始化器中成员的可见性和调用顺序。 6. 对象与集合初始化器同样是一种编译时技术。 7. LINQ体验(3)——C# 3.0新语言特性和 改进(下篇) 上一篇我们介绍了C# 3.0新语言特性和改进上部分，这篇我们继续介绍剩下的部分。 C# 3.0新语言特性和改进包括: , 自动属性(Auto-Implemented Properties) , 隐含类型局部变量(Local Variable Type Inference) , 匿名类型(Anonymous Types) , 对象与集合初始化器(Object and Collection Initializers) , 扩展方法(Extension Methods) , Lambda表达式和Lambda表达式树 (Lambda Expression and Lambda Expression Trees) 扩展方法(Extension Methods) 往往我们需要对CLR类型进行一些操作，但苦于无法扩展CLR类型的方法，只能创建一些helper方法，或者继承类。我们来修改上面的User类: public class User { public int Id { get; set; } public string Name { get; set; } public int Age { get; set; } public string Read() { return "Id:" + Id + "姓名:" + Name + "年龄:" + Age; } } 然后调用 var user = new { Id = 1, Name = "YJingLee", Age = 22 }; var str = user.Read(); 现在有了扩展方法就方便多了。 扩展方法允许开发人员往一个现有的CLR类型的公开契约(contract)中添加新的方法，而不用生成子类或者重新编译原来的类型。扩展方法有助于把今天动态语言中流行的对duck typing的支持之灵活性，与强类型语言之性能和编译时验证融合起来。——引用Scott博文 扩展方法是可以通过使用实例方法语法调用的静态方法。效果上，使得附加的方法扩展已存在类型和构造类型成为可能。他可以对现有类功能进行 扩充，从而使该类型的实例具有更多的方法(功能)。 扩展方法允许我们在不改变源代码的情况下扩展(即添加不能修改)现有类型中的实例方法。 扩展方法给我们一个怎样的思路呢,我们一步一步做一下～ 首先声明扩展方法:通过指定关键字this修饰方法的第一个参数。注意扩展方法仅可声明在静态类中。扩展方法具备所有常规静态方法的所有能力，可以使用实例方法语法来调用。接着就可以调用扩展方法了。下面通过一个具体的实例分析一下: 例如我们要检查一个字符串变量是否是合法的电子邮件地址,在.Net2.0框架下像这样: var email = "leeyongjing@gmail.com"; if (EmailValidator.IsValid(email)) { Response.Write("YJingLee提示:这是一个正确的邮件地址"); } 而使用扩展方法的话，我可以添加“IsValidEmailAddress()”方法到 string类本身中去，该方法返回当前字符串实例是否是个合法的字符串。 if (email.IsValidEmailAddress()) { Response.Write("YJingLee提示:这是一个正确的邮件地址"); } 我们是怎么把这个IsValidEmailAddress()方法添加到现有的string类里去的呢,先定义一个静态类，再定义“IsValidEmailAddress”这个静态 的法来实现的。 public static class Extensions//静态类 { public static bool IsValidEmailAddress(this string s) //静态方法和this { Regex regex = new Regex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$"); return regex.IsMatch(s); } } 注意，上面的静态方法在第一个类型是string的参数变量前有个“this”关键词，这告诉编译器，这个特定的扩展方法应该添加到类型为 “string”的对象中去。然后在IsValidEmailAddress()方法实现里，我可以访问调用该方法的实际string实例的所有公开属性 /方法/事件，取决于它是否是合法电子邮件地址来返回true/false。 扩展方法不仅能够应用到个别类型上，也能应用到.NET框架中任何基类或接口上。即可用于整个.NET框架丰富的可组合的框架层扩展。 扩展方法要点 1. 扩展方法的本质为将实例方法调用在编译期改变为静态类中的静态 方法调用。事实上，它确实拥有静态方法所具有的所有功能。 2. 扩展方法的作用域是整个namespace可见的，并且可以通过using namespace来导入其它命名空间中的扩展方法。 3. 扩展方法的优先级:现有实例方法优先级最高，其次为最近的 namespace下的静态类的静态方法，最后为较远的namespace下的静态 类的静态方法。 4. 扩展方法是一种编译时技术，注意与反射等运行时技术进行区别， 并慎重使用。 Lambda表达式和Lambda表达式树 (Lambda Expression and Lambda Expression Trees) Lambda表达式 我们从“所有字符串查找包含YJingLee子字符串”说起。在C# 2.0中，匿名方法允许我们以内联的方式来实现委托实例，它提供强大的函数式编程语言，但是标记显得相当的冗长和带有强制性。我们使用C# 2.0 中的匿名方法查找，代码如下: var inString = list.FindAll(delegate(string s) { return s.Indexof("YJingLee") >= 0; }); 现在可以使用C# 3.0带来的Lambda表达式允许我们使用一种更接近人的思维、更自然的方式来实现类似于匿名方法同样的效果，看下面的代码多么简洁: var inString = list.FindAll(s => s.Indexof("YJingLee") >= 0); Lambda表达式格式:(参数列表)=>表达式或语句块 具体意义:定义Lambda接受参数列表，运行表达式或语句块返回表达式或语句块的值传给这个参数列表。 Lambda表达式参数类型可以是隐式类型或显式类型。在显式列表中，每个参数的类型是显式指定的，在隐式列表中，参数的类型由Lambda表达式出现的语境自动推断类型。 Lambda表达式的参数列表可以有一个或多个参数，或者无参数。在有单一的隐型参数的lambda表达式中，圆括号可以从参数列表中省略。 例如: (x, y) => x * y;//多参数，隐式类型=>表达式 x => x * 10;//单参数，隐式类型=>表达式 x => { return x * 10; }; //单参数，隐式类型=>语句块 (int x) => x * 10;//单参数，显式类型=>表达式 (int x) => { return x * 10; };//单参数，显式类型=>语句块 () => Console.WriteLine(); //无参数 下面看这个例子: 在前面的帖子中，我们写了一个User类及增加了2个人，接下来，我们使用由LINQ提供的新的Where和Average方法来返回集合中的人的一个子集，以及计算这个集合中的人的平均年龄: List user = new List{ new User{Id=1,Name="YJingLee",Age=22}, new User{Id=2,Name="XieQing",Age=25}, }; //获取特定人时所用的过滤条件，p参数属于User类型 var results = user.Where(p => p.Name == "YJingLee").ToList(); //用User对象的Age值计算平均年龄 var average = user.Average(p => p.Age); 效果图如下: 对这个Lambda表达式做个简要分析: var resultsdelegate = user.Where(delegate(User p) { return p.Name == "YJingLee";// 返回一个布尔值 }); var averagedelegate = user.Average(delegate(User p) { return p.Age; }); Lambda表达式L可以被转换为委托类型D，需要满足以下条件: L的参数类型要与D的参数个数相等，类型相同，返回类型相同，无论是表达式，还是语句块。注意隐式类型要参与类型辨析。 Lambda表达式树 Lambda表达式树允许我们像处理数据(比如读取，修改)一样来处理Lambda表达式。我以一个例子简单说明: Expression> filter = n => (n * 3) < 5; BinaryExpression lt = (BinaryExpression)filter.Body; BinaryExpression mult = (BinaryExpression)lt.Left; ParameterExpression en = (ParameterExpression)mult.Left; ConstantExpression three = (ConstantExpression)mult.Right; ConstantExpression five = (ConstantExpression)lt.Right; var One = filter.Compile(); Console.WriteLine("Result: {0},{1}", One(5), One(1)); Console.WriteLine("({0} ({1} {2} {3}) {4})", lt.NodeType, mult.NodeType, en.Name, three.Value, five.Value); 效果图如下: Lambda表达式和Lambda表达式树要点 1. Lambda表达式的参数类型可以忽略，因为可以根据使用的上下文进 行推断。 2. Lambda表达式的主体(body)可以是表达式，也可以是语句块。 3. Lambda表达式传入的实参将参与类型推断，以及方法重载辨析。 4. Lambda表达式和表达式体可以被转换为表达式树。 5. 表达式树允许lambda表达式能够代表数据结构替代表示为执行代 码。 好了，我在这里简单的把C# 3.0新语言特性和改进说了一下，接下来，正式进入这个系列的主题部分——LINQ。为 了让大家了解，我换一种手 法来写，从一条一条LINQ to SQL语句分析来贯穿LINQ的知识点。一起体验LINQ带给我们的乐趣。 LINQ体验(4)——LINQ简介和LINQ to SQL 语句之Where 查询表达式(LINQ)简介 在上两篇我介绍了C#3.0新语特性和改进，这些新特性在我们编写程序时为我们提供了非常大的帮助。从这篇开始，我们开始一起来探讨LINQ。 LINQ是Language Integrated Query的简称，它是集成在.NET编程语言中的一种特性。已成为编程语言的一个组成部分，在编写程序时可以得到很好的编译时语法检查，丰富的元数据， 智能感知、静态类型等强类型语言的好处。并且它同时还使得查询可以方便地对内存中的信息进行查询而不仅仅只是外部数据源。 LINQ定义了一组标准查询操作符用于在所有基于.NET平台的编程语言中更加直接地声明跨越、过滤和投射操作的统一方式，标准查询操作符允许查询 作用于所有基于IEnumerable接口的源，并且它还允许适合于目标域或技术的第三方特定域操作符来扩大标准查询操作符集，更重要 的是，第三方操作符可以用它们自己的提供附加服务的实现来自由地替换标准查询操作符，根据LINQ模式的习俗，这些查询喜欢采用与标准查询操作符相同的语 言集成和工具支持。 我们来总体看看LINQ架构 在.NET3.5下，微软为我们提供了一些命名空间 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功能等。 说了这么多，我们还是用一个简单的实例说明一下LINQ带来的体验。 第一步:建立dbml(Database Mark Language。数据库描述语言，是一种xml格式的文档，用来描述数据库)文件，以Northwind数据库为例，上述Customers类被映射成一个表，对应数据库中的 Customers表 第二步:创建一个ASP.NET页面，在页面上加入一个GridView控件 第三步:编写代码进行数据绑定 第四步:运行显示结果。 好了，就说这么多吧，大家应该对LINQ有了总体的了解。最后我对LINQ还有一点疑惑，在此提出，请熟悉的朋友来探讨: 1. LINQ是在ADO.NET之上的，那么在将来它会代替ADO.NET吗, 2. 在大型项目中使用LINQ，它的效率如何呢, 接下来，我们开始从LINQ to SQL语句入手，来全面了解一下LINQ，就从最简单的Where说起吧，这个在编写程序中也最为常用。 Where操作 适用场景:实现过滤，查询等功能。 说明:与SQL命令中的Where作用相似，都是起到范围限定也就是过滤作用的，而判断条件就是它后面所接的子句。 Where操作包括3种形式，分别为简单形式、关系条件形式、First()形式。 下面分别用实例举例下: 1.简单形式: 例如:使用where筛选在伦敦的客户 var q = from c in db.Customers where c.City == "London" select c; 再如:筛选1994 年或之后雇用的雇员: var q = from e in db.Employees where e.HireDate >= new DateTime(1994, 1, 1) select e; 2.关系条件形式: 筛选库存量在订货点水平之下但未断货的产品: var q = from p in db.Products where p.UnitsInStock <= p.ReorderLevel && !p.Discontinued select p; 筛选出UnitPrice 大于10 或已停产的产品: var q = from p in db.Products where p.UnitPrice > 10m || p.Discontinued select p; 下面这个例子是调用两次where以筛选出UnitPrice大于10且已停产的 产品。 var q = db.Products.Where(p=>p.UnitPrice > 10m).Where(p=>p.Discontinued); 3.First()形式: 返回集合中的一个元素，其实质就是在SQL语句中加TOP (1)。 简单用法:选择表中的第一个发货方。 Shipper shipper = db.Shippers.First(); 元素:选择CustomerID 为“BONAP”的单个客户 Customer cust = db.Customers.First(c => c.CustomerID == "BONAP"); 条件:选择运费大于 10.00 的订单: Order ord = db.Orders.First(o => o.Freight > 10.00M); 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、LINQ 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种形式，分别为简单用法、 匿名类型形式、条件形式、指定类型形式、筛选形式、整形类型形式、 嵌套类型形式、本地方法调用形式、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}; 上面语句描述:使用 SELECT 和匿名类型返回仅含客户联系人姓名和电话号码的序列 var q = from e in db.Employees select new { Name = e.FirstName + " " + e.LastName, Phone = e.HomePhone }; 上面语句描述:使用SELECT和匿名类型返回仅含雇员姓名和电话号码的序列，并将FirstName和LastName字段合并为一个字段“Name”，此外在所得的序列中将HomePhone字段重命名为Phone。 var q = from p in db.Products select new { p.ProductID, HalfPrice = p.UnitPrice / 2 }; 上面语句描述:使用SELECT和匿名类型返回所有产品的ID以及HalfPrice(设置为产品单价除以2所得的值)的序列。 3.条件形式: 说明:生成SQL语句为:case when condition then else。 var q = from p in db.Products select new { p.ProductName, Availability = p.UnitsInStock - p.UnitsOnOrder < 0 ? "Out Of Stock" : "In Stock" }; 上面语句描述:使用SELECT和条件语句返回产品名称和产品供货状态的序列。 4.指定类型形式: 说明:该形式返回你自定义类型的对象集。 var q = from e in db.Employees select new Name { FirstName = e.FirstName, LastName = e.LastName }; 上面语句描述:使用SELECT和已知类型返回雇员姓名的序列。 5.筛选形式: 说明:结合where使用，起到过滤作用。 var q = from c in db.Customers where c.City == "London" select c.ContactName; 上面语句描述:使用SELECT和WHERE返回仅含伦敦客户联系人姓名的序列。 6.shaped形式(整形类型): 说明:其select操作使用了匿名对象，而这个匿名对象中，其属性也是个匿名对象。 var q = from c in db.Customers select new { c.CustomerID, CompanyInfo = new {c.CompanyName, c.City, c.Country}, ContactInfo = new {c.ContactName, c.ContactTitle} }; 语句描述:使用SELECT 和匿名类型返回有关客户的数据的整形子集。查询顾客的ID和公司信息(公司名称，城市，国家)以及联系信息(联系人和职位)。 7.嵌套类型形式: 说明:返回的对象集中的每个对象DiscountedProducts属性中，又包含一个集合。也就是每个对象也是一个集合类。 var q = from o in db.Orders select new { o.OrderID, DiscountedProducts = from od in o.OrderDetails where od.Discount > 0.0 select od, FreeShippingDiscount = o.Freight }; 语句描述:使用嵌套查询返回所有订单及其OrderID 的序列、打折订单中项目的子序列以及免送货所省下的金额。 8.本地方法调用形式(LocalMethodCall): 这个例子在查询中调用本地方法PhoneNumberConverter将电话号码转换为国际格式。 var q = from c in db.Customers where c.Country == "UK" || c.Country == "USA" select new { c.CustomerID, c.CompanyName, Phone = c.Phone, InternationalPhone = PhoneNumberConverter(c.Country, c.Phone) }; PhoneNumberConverter方法如下: public string PhoneNumberConverter(string Country, string Phone) { Phone = Phone.Replace(" ", "").Replace(")", ")-"); switch (Country) { case "USA": return "1-" + Phone; case "UK": return "44-" + Phone; default: return Phone; } } 下面也是使用了这个方法将电话号码转换为国际格式并创建XDocument XDocument doc = new XDocument( new XElement("Customers", from c in db.Customers where c.Country == "UK" || c.Country == "USA" select (new XElement("Customer", new XAttribute("CustomerID", c.CustomerID), new XAttribute("CompanyName", c.CompanyName), new XAttribute("InterationalPhone", PhoneNumberConverter(c.Country, c.Phone)) )))); 9.Distinct形式: 说明:筛选字段中不相同的值。用于查询不重复的结果集。生成SQL语句为:SELECT DISTINCT [City] FROM [Customers] var q = ( from c in db.Customers select c.City ) .Distinct(); 语句描述:查询顾客覆盖的国家。 Count/Sum/Min/Max/Avg操作符 适用场景:统计数据吧，比如统计一些数据的个数，求和，最小值，最大值，平均数。 Count 说明:返回集合中的元素个数，返回INT类型;不延迟。生成SQL语句为:SELECT COUNT(*) FROM 1.简单形式: 得到数据库中客户的数量: var q = db.Customers.Count(); 2.带条件形式: 得到数据库中未断货产品的数量: var q = db.Products.Count(p => !p.Discontinued); LongCount 说明:返回集合中的元素个数，返回LONG类型;不延迟。对于元素个数较多的集合可视情况可以选用LongCount来统计元素个数，它返回long类型，比较精确。生成SQL语句为:SELECT COUNT_BIG(*) FROM var q = db.Customers.LongCount(); Sum 说明:返回集合中数值类型元素之和，集合应为INT类型集合;不延迟。 生成SQL语句为:SELECT SUM(„) FROM 1.简单形式: 得到所有订单的总运费: var q = db.Orders.Select(o => o.Freight).Sum(); 2.映射形式: 得到所有产品的订货总数: var q = db.Products.Sum(p => p.UnitsOnOrder); Min 说明:返回集合中元素的最小值;不延迟。生成SQL语句为:SELECT MIN(„) FROM 1.简单形式: 查找任意产品的最低单价: var q = db.Products.Select(p => p.UnitPrice).Min(); 2.映射形式: 查找任意订单的最低运费: var q = db.Orders.Min(o => o.Freight); 3.元素: 查找每个类别中单价最低的产品: var categories = from p in db.Products group p by p.CategoryID into g select new { CategoryID = g.Key, CheapestProducts = from p2 in g where p2.UnitPrice == g.Min(p3 => p3.UnitPrice) select p2 }; Max 说明:返回集合中元素的最大值;不延迟。生成SQL语句为:SELECT MAX(„) FROM 1.简单形式: 查找任意雇员的最近雇用日期: var q = db.Employees.Select(e => e.HireDate).Max(); 2.映射形式: 查找任意产品的最大库存量: var q = db.Products.Max(p => p.UnitsInStock); 3.元素: 查找每个类别中单价最高的产品: var categories = from p in db.Products group p by p.CategoryID into g select new { g.Key, MostExpensiveProducts = from p2 in g where p2.UnitPrice == g.Max(p3 => p3.UnitPrice) select p2 }; Average 说明:返回集合中的数值类型元素的平均值。集合应为数字类型集合，其返回值类型为double;不延迟。生成SQL语句为:SELECT AVG(„) FROM 1.简单形式: 得到所有订单的平均运费: var q = db.Orders.Select(o => o.Freight).Average(); 2.映射形式: 得到所有产品的平均单价: var q = db.Products.Average(p => p.UnitPrice); 3.元素: 查找每个类别中单价高于该类别平均单价的产品: var categories = from p in db.Products group p by p.CategoryID into g select new { g.Key, ExpensiveProducts = from p2 in g where p2.UnitPrice > g.Average(p3 => p3.UnitPrice) select p2 }; Aggregate 说明:根据输入的表达式获取聚合值;不延迟。即是说:用一个种子值与当前元素通过指定的函数来进行对比来遍历集合中的元素，符合条件的元素保留下来。如果没有指定种子值的话，种子值默认为集合的第一个元素。 下面用一个表格总结一下这篇说的LINQ to SQL语句 Where 过滤;延迟 Select 选择;延迟 Distinct 查询不重复的结果集;延迟 Count 返回集合中的元素个数，返回INT类型;不延迟 LongCount 返回集合中的元素个数，返回LONG类型;不延迟 返回集合中数值类型元素之和，集合应为INT类型集合;不延Sum 迟 Min 返回集合中元素的最小值;不延迟 Max 返回集合中元素的最大值;不延迟 返回集合中的数值类型元素的平均值。集合应为数字类型集合，Average 其返回值类型为double;不延迟 Aggregate 根据输入的表达式获取聚合值;不延迟 LINQ体验(6)——LINQ to SQL语句之Join和Order By Join操作 适用场景:在我们表关系中有一对一关系，一对多关系，多对多关系等。对各个表之间的关系，就用这些实现对多个表的操作。 说明:在Join操作中，分别为Join(Join查询), SelectMany(Select一对多选择)和GroupJoin(分组Join查询)。 该扩展方法对两个序列中键匹配的元素进行inner join操作 SelectMany 说明:我们在写查询语句时，如果被翻译成SelectMany需要满足2个条件。1:查询语句中没有join和into，2:必须出现EntitySet。在我们表关系中有一对一关系，一对多关系，多对多关系等，下面分别介绍一下。 1.一对多关系(1 to Many): var q = from c in db.Customers from o in c.Orders where c.City == "London" select o; 语句描述:Customers与Orders是一对多关系。即Orders在Customers类中以EntitySet形式出现。所以第二个 from是从c.Orders而不是 db.Orders里进行筛选。这个例子在From子句中使用外键导航选择伦敦客 户的所有订单。 var q = from p in db.Products where p.Supplier.Country == "USA" && p.UnitsInStock == 0 select p; 语句描述:这一句使用了p.Supplier.Country条件，间接关联了Supplier表。这个例子在Where子句中使用外键导航筛选其供应商在美国且缺货的 产品。生成SQL语句为: SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0].[ReorderLevel], [t0].[Discontinued] FROM [dbo].[Products] AS [t0] LEFT OUTER JOIN [dbo].[Suppliers] AS [t1] ON [t1].[SupplierID] = [t0].[SupplierID] WHERE ([t1].[Country] = @p0) AND ([t0].[UnitsInStock] = @p1) -- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [USA] -- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0] 2.多对多关系(Many to Many): var q = from e in db.Employees from et in e.EmployeeTerritories where e.City == "Seattle" select new { e.FirstName, e.LastName, et.Territory.TerritoryDescription }; 说明:多对多关系一般会涉及三个表(如果有一个表是自关联的，那有可 能只有2个表)。这一句语句涉及Employees, EmployeeTerritories, Territories三个表。它们的关系是1:M:1。Employees和Territories没有很明确的关系。 语句描述:这个例子在From子句中使用外键导航筛选在西雅图的雇员， 同时列出其所在地区。这条生成SQL语句为: SELECT [t0].[FirstName], [t0].[LastName], [t2].[TerritoryDescription] FROM [dbo].[Employees] AS [t0] CROSS JOIN [dbo].[EmployeeTerritories] AS [t1] INNER JOIN [dbo].[Territories] AS [t2] ON [t2].[TerritoryID] = [t1].[TerritoryID] WHERE ([t0].[City] = @p0) AND ([t1].[EmployeeID] = [t0].[EmployeeID]) -- @p0: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Seattle] 3.自联接关系: var q = from e1 in db.Employees from e2 in e1.Employees where e1.City == e2.City select new { FirstName1 = e1.FirstName, LastName1 = e1.LastName, FirstName2 = e2.FirstName, LastName2 = e2.LastName, e1.City }; 语句描述:这个例子在select 子句中使用外键导航筛选成对的雇员，每对中一个雇员隶属于另一个雇员，且两个雇员都来自相同城市。生成SQL语句为: SELECT [t0].[FirstName] AS [FirstName1], [t0].[LastName] AS [LastName1],[t1].[FirstName] AS [FirstName2], [t1].[LastName] AS [LastName2],[t0].[City] FROM [dbo].[Employees] AS [t0], [dbo].[Employees] AS [t1] WHERE ([t0].[City] = [t1].[City]) AND ([t1].[ReportsTo] = [t0].[EmployeeID]) GroupJoin 像上面所说的，没有join和into，被翻译成SelectMany，同时有join和into时，那么就被翻译为GroupJoin。在这里into的概念是对其结果进行重新命名。 1.双向联接(Two way join): 此示例显式联接两个表并从这两个表投影出结果: var q = from c in db.Customers join o in db.Orders on c.CustomerID equals o.CustomerID into orders select new { c.ContactName, OrderCount = orders.Count() }; 说明:在一对多关系中，左边是1，它每条记录为c(from c in db.Customers)，右边是Many，其每条记录叫做o ( join o in db.Orders )，每对应左边的一个c，就会有一组o，那这一组o，就叫做orders，也就是说，我们把一组o命名为orders，这就是into用途。这也就是为什 么在select语句中，orders可以调用聚合函数Count。在T-SQL中，使用其内嵌的T-SQL返回值作为字段值。如图所示: 生成SQL语句为: SELECT [t0].[ContactName], ( SELECT COUNT(*) FROM [dbo].[Orders] AS [t1] WHERE [t0].[CustomerID] = [t1].[CustomerID] ) AS [OrderCount] FROM [dbo].[Customers] AS [t0] 2.三向联接(There way join): 此示例显式联接三个表并分别从每个表投影出结果: var q = from c in db.Customers join o in db.Orders on c.CustomerID equals o.CustomerID into ords join e in db.Employees on c.City equals e.City into emps select new { c.ContactName, ords = ords.Count(), emps = emps.Count() }; 生成SQL语句为: SELECT [t0].[ContactName], ( SELECT COUNT(*) FROM [dbo].[Orders] AS [t1] WHERE [t0].[CustomerID] = [t1].[CustomerID] ) AS [ords], ( SELECT COUNT(*) FROM [dbo].[Employees] AS [t2] WHERE [t0].[City] = [t2].[City] ) AS [emps] FROM [dbo].[Customers] AS [t0] 3.左外部联接(Left Outer Join): 此示例说明如何通过使用 此示例说明如何通过使用DefaultIfEmpty() 获取左外部联接。在雇员没有订单时，DefaultIfEmpty()方法返回null: var q = from e in db.Employees join o in db.Orders on e equals o.Employee into ords from o in ords.DefaultIfEmpty() select new { e.FirstName, e.LastName, Order = o }; 说明:以Employees左表，Orders右表，Orders 表中为空时，用null值填充。Join的结果重命名ords，使用DefaultIfEmpty()函数对其再次查询。其最后的结果中有个Order，因为from o in ords.DefaultIfEmpty() 是对ords组再一次遍历，所以，最后结果中的Order并不是一个集合。但是，如果没有from o in ords.DefaultIfEmpty() 这句，最后的select语句写成select new { e.FirstName, e.LastName, Order = ords }的话，那么Order就是一个集合。 4.投影的Let赋值(Projected let assignment): 说明:let语句是重命名。let位于第一个from和select语句之间。 这个例子从联接投影出最终“Let”表达式: var q = from c in db.Customers join o in db.Orders on c.CustomerID equals o.CustomerID into ords let z = c.City + c.Country from o in ords select new { c.ContactName, o.OrderID, z }; 5.组合键(Composite Key): 这个例子显示带有组合键的联接: var q = from o in db.Orders from p in db.Products join d in db.OrderDetails on new { o.OrderID, p.ProductID } equals new { d.OrderID, d.ProductID } into details from d in details select new { o.OrderID, p.ProductID, d.UnitPrice }; 说明:使用三个表，并且用匿名类来说明:使用三个表，并且用匿名类来表示它们之间的关系。它们之间的关系不能用一个键描述清楚，所以用匿名类，来表示组合键。还有一种是两个表之间是用组合键表示关系的，不需要使用匿名类。 6.可为null/不可为null的键关系(Nullable/Nonnullable Key Relationship): 这个实例显示如何构造一侧可为 null 而另一侧不可为 null 的联接: var q = from o in db.Orders join e in db.Employees on o.EmployeeID equals (int?)e.EmployeeID into emps from e in emps select new { o.OrderID, e.FirstName }; Order By操作 适用场景:对查询出的语句进行排序，比如按时间排序等等。 说明:按指定表达式对集合排序;延迟，:按指定表达式对集合排序;延 迟，默认是升序，加上descending表示降序，对应的扩展方法是OrderBy 和OrderByDescending 1.简单形式 这个例子使用 orderby 按雇用日期对雇员进行排序: var q = from e in db.Employees orderby e.HireDate select e; 说明:默认为升序 2.带条件形式 注意:Where和Order By的顺序并不重要。而在T-SQL中，Where和Order By有严格的位置限制。 var q = from o in db.Orders where o.ShipCity == "London" orderby o.Freight select o; 语句描述:使用where和orderby按运费进行排序。 3.降序排序 var q = from p in db.Products orderby p.UnitPrice descending select p; 4.ThenBy 语句描述:使用复合的 orderby 对客户进行排序，进行排序: var q = from c in db.Customers orderby c.City, c.ContactName select c; 说明:按多个表达式进行排序，例如先按City排序，当City相同时，按ContactName排序。这一句用Lambda表达式像这样写: var q = db.Customers .OrderBy(c => c.City) .ThenBy(c => c.ContactName).ToList(); 在T-SQL中没有ThenBy语句，其依然翻译为OrderBy，所以也可以用下面语句来表达: var q = db.Customers .OrderBy(c => c.ContactName) .OrderBy(c => c.City).ToList(); 所要注意的是，多个OrderBy操作时，级连方式是按逆序。 对于降序的，用相应的降序操作符替换即可。 var q = db.Customers .OrderByDescending(c => c.City) .ThenByDescending(c => c.ContactName).ToList(); 需要说明的是，OrderBy操作，不支持按type排序，也不支持匿名类。比如 var q = db.Customers .OrderBy(c => new { c.City, c.ContactName }).ToList(); 会被抛出异常。错误是前面的操作有匿名类，再跟OrderBy时，比较的是类别。比如 var q = db.Customers .Select(c => new { c.City, c.Address }) .OrderBy(c => c).ToList(); 如果你想使用OrderBy(c => c)，其前提条件是，前面步骤中，所产生的对象的类别必须为C#语言的基本类型。比如下句，这里City为string类型。 var q = db.Customers .Select(c => c.City) .OrderBy(c => c).ToList(); 5.ThenByDescending 这两个扩展方式都是用在OrderBy/OrderByDescending之后的，第一个ThenBy/ThenByDescending扩展方法作为第二位排序依据，第二个ThenBy/ThenByDescending则作为第三位排序依据，以此类推 var q = from o in db.Orders where o.EmployeeID == 1 orderby o.ShipCountry, o.Freight descending select o; 语句描述:使用orderby先按发往国家再按运费从高到低的顺序对 EmployeeID 1 的订单进行排序。 6.带GroupBy形式 var q = from p in db.Products group p by p.CategoryID into g orderby g.Key select new { g.Key, MostExpensiveProducts = from p2 in g where p2.UnitPrice == g.Max(p3 => p3.UnitPrice) select p2 }; 语句描述:使用orderby、Max 和 Group By 得出每种类别中单价最高的产品，并按 CategoryID 对这组产品进行排序。 LINQ体验(7)——LINQ to SQL语句之Group By/Having和 Exists/In/Any/All/Contains 我们继续讲解LINQ to SQL语句，这篇我们来讨论Group By/Having操作符和Exists/In/Any/All/Contains操作符。 Group By/Having操作符 适用场景:分组数据，为我们查找数据缩小范围。 说明:分配并返回对传入参数进行分组操作后的可枚举对象。分组;延迟 1.简单形式: var q = from p in db.Products group p by p.CategoryID into g select g; 语句描述:使用Group By按CategoryID划分产品。 说明:from p in db.Products 表示从表中将产品对象取出来。group p by p.CategoryID into g表示对p按CategoryID字段归类。其结果命名为g，一旦重新命名，p的作用域就结束了，所以，最后select时，只能select g。当然，也不必重新命名可以这样写: var q = from p in db.Products group p by p.CategoryID; 我们用示意图表示: 如果想遍历某类别中所有记录，这样: foreach (var gp in q) { if (gp.Key == 2) { foreach (var item in gp) { //do something } } } 2.Select匿名类: var q = from p in db.Products group p by p.CategoryID into g select new { CategoryID = g.Key, g }; 说明:在这句LINQ语句中，有2个property:CategoryID和g。这个匿名类，其实质是对返回结果集重新进行了包装。把g的property封装成一个完整的分组。如下图所示: 如果想遍历某匿名类中所有记录，要这么做: foreach (var gp in q) { if (gp.CategoryID == 2) { foreach (var item in gp.g) { //do something } } } 3.最大值 var q = from p in db.Products group p by p.CategoryID into g select new { g.Key, MaxPrice = g.Max(p => p.UnitPrice) }; 语句描述:使用Group By和Max查找每个CategoryID的最高单价。 说明:先按CategoryID归类，判断各个分类产品中单价最大的Products。取出CategoryID值，并把UnitPrice值赋给MaxPrice。 4.最小值 var q = from p in db.Products group p by p.CategoryID into g select new { g.Key, MinPrice = g.Min(p => p.UnitPrice) }; 语句描述:使用Group By和Min查找每个CategoryID的最低单价。 说明:先按CategoryID归类，判断各个分类产品中单价最小的Products。取出CategoryID值，并把UnitPrice值赋给MinPrice。 5.平均值 var q = from p in db.Products group p by p.CategoryID into g select new { g.Key, AveragePrice = g.Average(p => p.UnitPrice) }; 语句描述:使用Group By和Average得到每个CategoryID的平均单价。 说明:先按CategoryID归类，取出CategoryID值和各个分类产品中单价的平均值。 6.求和 var q = from p in db.Products group p by p.CategoryID into g select new { g.Key, TotalPrice = g.Sum(p => p.UnitPrice) }; 语句描述:使用Group By和Sum得到每个CategoryID 的单价总计。 说明:先按CategoryID归类，取出CategoryID值和各个分类产品中单价的总和。 7.计数 var q = from p in db.Products group p by p.CategoryID into g select new { g.Key, NumProducts = g.Count() }; 语句描述:使用Group By和Count得到每个CategoryID中产品的数量。 说明:先按CategoryID归类，取出CategoryID值和各个分类产品的数量。 8.带条件计数 var q = from p in db.Products group p by p.CategoryID into g select new { g.Key, NumProducts = g.Count(p => p.Discontinued) }; 语句描述:使用Group By和Count得到每个CategoryID中断货产品的数量。 说明:先按CategoryID归类，取出CategoryID值和各个分类产品的断货数量。 Count函数里，使用了Lambda表达式，Lambda表达式中的p，代表这个组里的一个元素或对象，即某一个产品。 9.Where限制 var q = from p in db.Products group p by p.CategoryID into g where g.Count() >= 10 select new { g.Key, ProductCount = g.Count() }; 语句描述:根据产品的―ID分组，查询产品数量大于10的ID和产品数量。 这个示例在Group By子句后使用Where子句查找所有至少有10种产品的类别。 说明:在翻译成SQL语句时，在最外层嵌套了Where条件。 10.多列(Multiple Columns) var categories = from p in db.Products group p by new { p.CategoryID, p.SupplierID } into g select new { g.Key, g }; 语句描述:使用Group By按CategoryID和SupplierID将产品分组。 说明: 既按产品的分类，又按供应商分类。在by后面，new出来一个匿名类。这里，Key其实质是一个类的对象，Key包含两个Property:CategoryID、SupplierID。用g.Key.CategoryID可以遍历CategoryID的值。 11.表达式(Expression) var categories = from p in db.Products group p by new { Criterion = p.UnitPrice > 10 } into g select g; 语句描述:使用Group By返回两个产品序列。第一个序列包含单价大于10的产品。第二个序列包含单价小于或等于10的产品。 说明:按产品单价是否大于10分类。其结果分为两类，大于的是一类，小于及等于为另一类。 Exists/In/Any/All/Contains操作符 适用场景:用于判断集合中元素，进一步缩小范围。 Any 说明:用于判断集合中是否有元素满足某一条件;不延迟。(若条件为空，则集合只要不为空就返回True，否则为False)。有2种形式，分别为简单形式和带条件形式。 1.简单形式: 仅返回没有订单的客户: var q = from c in db.Customers where !c.Orders.Any() select c; 生成SQL语句为: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE NOT (EXISTS( SELECT NULL AS [EMPTY] FROM [dbo].[Orders] AS [t1] WHERE [t1].[CustomerID] = [t0].[CustomerID] )) 2.带条件形式: 仅返回至少有一种产品断货的类别: var q = from c in db.Categories where c.Products.Any(p => p.Discontinued) select c; 生成SQL语句为: SELECT [t0].[CategoryID], [t0].[CategoryName], [t0].[Description], [t0].[Picture] FROM [dbo].[Categories] AS [t0] WHERE EXISTS( SELECT NULL AS [EMPTY] FROM [dbo].[Products] AS [t1] WHERE ([t1].[Discontinued] = 1) AND ([t1].[CategoryID] = [t0].[CategoryID]) ) All 说明:用于判断集合中所有元素是否都满足某一条件;不延迟 1.带条件形式 var q = from c in db.Customers where c.Orders.All(o => o.ShipCity == c.City) select c; 语句描述:这个例子返回所有订单都运往其所在城市的客户或未下订单的客户。 Contains 说明:用于判断集合中是否包含有某一元素;不延迟。它是对两个序列进行连接操作的。 string[] customerID_Set = new string[] { "AROUT", "BOLID", "FISSA" }; var q = ( from o in db.Orders where customerID_Set.Contains(o.CustomerID) select o).ToList(); 语句描述:查找"AROUT", "BOLID" 和 "FISSA" 这三个客户的订单。 先定义了一个数组，在LINQ to SQL中使用Contains，数组中包含了所有的CustomerID，即返回结果中，所有的CustomerID都在这个集合内。也就是in。 你也可以把数组的定义放在LINQ to SQL语句里。比如: var q = ( from o in db.Orders where ( new string[] { "AROUT", "BOLID", "FISSA" }) .Contains(o.CustomerID) select o).ToList(); Not Contains则取反: var q = ( from o in db.Orders where !( new string[] { "AROUT", "BOLID", "FISSA" }) .Contains(o.CustomerID) select o).ToList(); 1.包含一个对象: var order = (from o in db.Orders where o.OrderID == 10248 select o).First(); var q = db.Customers.Where(p => p.Orders.Contains(order)).ToList(); foreach (var cust in q) { foreach (var ord in cust.Orders) { //do something } } 语句描述:这个例子使用Contain查找哪个客户包含OrderID为10248的订单。 2.包含多个值: string[] cities = new string[] { "Seattle", "London", "Vancouver", "Paris" }; var q = db.Customers.Where(p=>cities.Contains(p.City)).ToList(); 语句描述:这个例子使用Contains查找其所在城市为西雅图、伦敦、巴黎或温哥华的客户。 总结一下这篇我们说明了以下语句: Group By/Having 分组数据;延迟 Any 用于判断集合中是否有元素满足某一条件;不延迟 All 用于判断集合中所有元素是否都满足某一条件;不延迟 Contains 用于判断集合中是否包含有某一元素;不延迟 LINQ体验(8)——LINQ to SQL语句之Union All/Union/Intersect和Top/Bottom 和Paging和SqlMethods 我们继续讲解LINQ to SQL语句，这篇我们来讨论Union All/Union/Intersect操作和Top/Bottom操作和Paging操作和SqlMethods操作 。 Union All/Union/Intersect操作 适用场景:对两个集合的处理，例如追加、合并、取相同项、相交项等等。 Concat(连接) 说明:连接不同的集合，不会自动过滤相同项;延迟。 1.简单形式: var q = ( from c in db.Customers select c.Phone ).Concat( from c in db.Customers select c.Fax ).Concat( from e in db.Employees select e.HomePhone ); 语句描述:返回所有消费者和雇员的电话和传真。 2.复合形式: var q = ( from c in db.Customers select new { Name = c.CompanyName, c.Phone } ).Concat( from e in db.Employees select new { Name = e.FirstName + " " + e.LastName, Phone = e.HomePhone } ); 语句描述:返回所有消费者和雇员的姓名和电话。 Union(合并) 说明:连接不同的集合，自动过滤相同项;延迟。即是将两个集合进行合并操作，过滤相同的项。 var q = ( from c in db.Customers select c.Country ).Union( from e in db.Employees select e.Country ); 语句描述:查询顾客和职员所在的国家。 Intersect(相交) 说明:取相交项;延迟。即是获取不同集合的相同项(交集)。即先遍历第一个集合，找出所有唯一的元素，然后遍历第二个集合，并将每个元素与前面找出的元素作对比，返回所有在两个集合内都出现的元素。 var q = ( from c in db.Customers select c.Country ).Intersect( from e in db.Employees select e.Country ); 语句描述:查询顾客和职员同在的国家。 Except(与非) 说明:排除相交项;延迟。即是从某集合中删除与另一个集合中相同的项。先遍历第一个集合，找出所有唯一的元素，然后再遍历第二个集合，返回第二个集合中所有未出现在前面所得元素集合中的元素。 var q = ( from c in db.Customers select c.Country ).Except( from e in db.Employees select e.Country ); 语句描述:查询顾客和职员不同的国家。 Top/Bottom操作 适用场景:适量的取出自己想要的数据，不是全部取出，这样性能有所加 强。 Take 说明:获取集合的前n个元素;延迟。即只返回限定数量的结果集。 var q = ( from e in db.Employees orderby e.HireDate select e) .Take(5); 语句描述:选择所雇用的前5个雇员。 Skip 说明:跳过集合的前n个元素;延迟。即我们跳过给定的数目返回后面的 结果集。 var q = ( from p in db.Products orderby p.UnitPrice descending select p) .Skip(10); 语句描述:选择10种最贵产品之外的所有产品。 TakeWhile 说明:直到某一条件成立就停止获取;延迟。即用其条件去依次判断源序列中的元素，返回符合判断条件的元素，该判断操作将在返回false或源序列的末尾结束 。 SkipWhile 说明:直到某一条件成立就停止跳过;延迟。即用其条件去判断源序列中的元素并且跳过第一个符合判断条件的元素，一旦判断返回false，接下来将不再进行判断并返回剩下的所有元素。 Paging(分页)操作 适用场景:结合Skip和Take就可实现对数据分页操作。 1.索引 var q = ( from c in db.Customers orderby c.ContactName select c) .Skip(50) .Take(10); 语句描述:使用Skip和Take运算符进行分页，跳过前50条记录，然后返回接下来10条记录，因此提供显示Products表第6页的数据。 2.按唯一键排序 var q = ( from p in db.Products where p.ProductID > 50 orderby p.ProductID select p) .Take(10); 语句描述:使用Where子句和Take运算符进行分页，首先筛选得到仅50 (第5页最后一个ProductID)以上的ProductID，然后按ProductID排序，最后取前10个结果，因此提供Products表第6页的数据。请注意，此方法仅适用于按唯一键排序的情况。 SqlMethods操作 在LINQ to SQL语句中，为我们提供了SqlMethods操作，进一步为我们提供了方便，例如Like方法用于自定义通配表达式，Equals用于相比较是否相等。 Like 自定义的通配表达式。%表示零长度或任意长度的字符串;_表示一个字符;[]表示在某范围区间的一个字符;[^]表示不在某范围区间的一个字符。比如查询消费者ID以“C”开头的消费者。 var q = from c in db.Customers where SqlMethods.Like(c.CustomerID, "C%") select c; 比如查询消费者ID没有“AXOXT”形式的消费者: var q = from c in db.Customers where !SqlMethods.Like(c.CustomerID, "A_O_T") select c; DateDiffDay 说明:在两个变量之间比较。分别有:DateDiffDay、DateDiffHour、DateDiffMillisecond、DateDiffMinute、DateDiffMonth、DateDiffSecond、DateDiffYear var q = from o in db.Orders where SqlMethods .DateDiffDay(o.OrderDate, o.ShippedDate) < 10 select o; 语句描述:查询在创建订单后的 10 天内已发货的所有订单。 已编译查询操作(Compiled Query) 说明:在之前我们没有好的方法对写出的SQL语句进行编辑重新查询，现在我们可以这样做，看下面一个例子: //1.创建compiled query NorthwindDataContext db = new NorthwindDataContext(); var fn = CompiledQuery.Compile( (NorthwindDataContext db2, string city) => from c in db2.Customers where c.City == city select c); //2.查询城市为London的消费者,用LonCusts集合表示，这时可以用数据控件绑定 var LonCusts = fn(db, "London"); //3.查询城市为Seattle的消费者 var SeaCusts = fn(db, "Seattle"); 语句描述:这个例子创建一个已编译查询，然后使用它检索输入城市的客户。 LINQ体验(9)——LINQ to SQL语句之Insert/Update/Delete操作 我们继续讲解LINQ to SQL语句，这篇我们来讨论Insert/Update/Delete 操作。这个在我们的程序中最为常用了。我们直接看例子。 Insert/Update/Delete操作 插入(Insert) 1.简单形式 说明:new一个对象，使用InsertOnSubmit方法将其加入到对应的集合中，使用SubmitChanges()提交到数据库。 NorthwindDataContext db = new NorthwindDataContext(); var newCustomer = new Customer { CustomerID = "MCSFT", CompanyName = "Microsoft", ContactName = "John Doe", ContactTitle = "Sales Manager", Address = "1 Microsoft Way", City = "Redmond", Region = "WA", PostalCode = "98052", Country = "USA", Phone = "(425) 555-1234", Fax = null }; db.Customers.InsertOnSubmit(newCustomer); db.SubmitChanges(); 语句描述:使用InsertOnSubmit方法将新客户添加到Customers 表对象。调用SubmitChanges 将此新Customer保存到数据库。 2.一对多关系 说明:Category与Product是一对多的关系，提交Category(一端)的数据时，LINQ to SQL会自动将Product(多端)的数据一起提交。 var newCategory = new Category { CategoryName = "Widgets", Description = "Widgets are the ……" }; var newProduct = new Product { ProductName = "Blue Widget", UnitPrice = 34.56M, Category = newCategory }; db.Categories.InsertOnSubmit(newCategory); db.SubmitChanges(); 语句描述:使用InsertOnSubmit方法将新类别添加到Categories表中，并将新Product对象添加到与此新Category有外键关系的Products表中。调用SubmitChanges将这些新对象及其关系保存到数据库。 3.多对多关系 说明:在多对多关系中，我们需要依次提交。 var newEmployee = new Employee { FirstName = "Kira", LastName = "Smith" }; var newTerritory = new Territory { TerritoryID = "12345", TerritoryDescription = "Anytown", Region = db.Regions.First() }; var newEmployeeTerritory = new EmployeeTerritory { Employee = newEmployee, Territory = newTerritory }; db.Employees.InsertOnSubmit(newEmployee); db.Territories.InsertOnSubmit(newTerritory); db.EmployeeTerritories.InsertOnSubmit(newEmployeeTerritory ); db.SubmitChanges(); 语句描述:使用InsertOnSubmit方法将新雇员添加到Employees 表中，将新Territory添加到Territories表中，并将新EmployeeTerritory对 象添加到与此新Employee对象和新 Territory对象有外键关系的EmployeeTerritories表中。调用SubmitChanges将这些新对象及其关系保持到数据库。 4.使用动态CUD重写(Override using Dynamic CUD) 说明:CUD就是Create、Update、Delete的缩写。下面的例子就是新建一个ID(主键)为32的Region，不考虑数据库中有没有ID为32的数据，如果有则替换原来的数据，没有则插入。 Region nwRegion = new Region() { RegionID = 32, RegionDescription = "Rainy" }; db.Regions.InsertOnSubmit(nwRegion); db.SubmitChanges(); 语句描述:使用DataContext提供的分部方法InsertRegion插入一个区域。对SubmitChanges 的调用调用InsertRegion 重写，后者使用动态CUD运行Linq To SQL生成的默认SQL查询。 更新(Update) 说明:更新操作，先获取对象，进行修改操作之后，直接调用SubmitChanges()方法即可提交。注意，这里是在同一个DataContext中，对于不同的DataContex看下面的讲解。 1.简单形式 Customer cust = db.Customers.First(c => c.CustomerID == "ALFKI"); cust.ContactTitle = "Vice President"; db.SubmitChanges(); 语句描述:使用SubmitChanges将对检索到的一个Customer对象做出的更新保持回数据库。 2.多项更改 var q = from p in db.Products where p.CategoryID == 1 select p; foreach (var p in q) { p.UnitPrice += 1.00M; } db.SubmitChanges(); 语句描述:使用SubmitChanges将对检索到的进行的更新保持回数据库。 删除(Delete) 1.简单形式 说明:调用DeleteOnSubmit方法即可。 OrderDetail orderDetail = db.OrderDetails.First (c => c.OrderID == 10255 && c.ProductID == 36); db.OrderDetails.DeleteOnSubmit(orderDetail); db.SubmitChanges(); 语句描述:使用DeleteOnSubmit方法从OrderDetail 表中删除OrderDetail对象。调用SubmitChanges 将此删除保持到数据库。 2.一对多关系 说明:Order与OrderDetail是一对多关系，首先DeleteOnSubmit其OrderDetail(多端)，其次DeleteOnSubmit其Order(一端)。因为一端是主键。 var orderDetails = from o in db.OrderDetails where o.Order.CustomerID == "WARTH" && o.Order.EmployeeID == 3 select o; var order = (from o in db.Orders where o.CustomerID == "WARTH" && o.EmployeeID == 3 select o).First(); foreach (OrderDetail od in orderDetails) { db.OrderDetails.DeleteOnSubmit(od); } db.Orders.DeleteOnSubmit(order); db.SubmitChanges(); 语句描述语句描述:使用DeleteOnSubmit方法从Order 和Order Details表中删除Order和Order Detail对象。首先从Order Details删除，然后从Orders删除。调用SubmitChanges将此删除保持到数据库。 3.推理删除(Inferred Delete) 说明:Order与OrderDetail是一对多关系，在上面的例子，我们全部删除CustomerID为WARTH和EmployeeID为3 的数据，那么我们不须全部删除呢,例如Order的OrderID为10248的OrderDetail有很多，但是我们只要删除ProductID为11的OrderDetail。这时就用Remove方法。 Order order = db.Orders.First(x => x.OrderID == 10248); OrderDetail od = order.OrderDetails.First(d => d.ProductID == 11); order.OrderDetails.Remove(od); db.SubmitChanges(); 语句描述语句描述:这个例子说明在实体对象的引用实体将该对象从其EntitySet 中移除时，推理删除如何导致在该对象上发生实际的删除操作。仅当实体的关联映射将DeleteOnNull设置为true且CanBeNull 为false 时，才会发生推理删除行为。 使用Attach更新(Update with Attach) 说明:在对于在不同的DataContext之间，使用Attach方法来更新数据。例如在一个名为tempdb的 NorthwindDataContext中，查询出Customer和Order，在另一个NorthwindDataContext 中，Customer的地址更新为123 First Ave，Order的CustomerID 更新为CHOPS。 //通常，通过从其他层反序列化 XML 来获取要附加的实体 //不支持将实体从一个DataContext附加到另一个DataContext //因此若要复制反序列化实体的操作，将在此处重新创建这些实体 Customer c1; List deserializedOrders = new List(); Customer deserializedC1; using (NorthwindDataContext tempdb = new NorthwindDataContext()) { c1 = tempdb.Customers.Single(c => c.CustomerID == "ALFKI"); deserializedC1 = new Customer { Address = c1.Address, City = c1.City, CompanyName = c1.CompanyName, ContactName = c1.ContactName, ContactTitle = c1.ContactTitle, Country = c1.Country, CustomerID = c1.CustomerID, Fax = c1.Fax, Phone = c1.Phone, PostalCode = c1.PostalCode, Region = c1.Region }; Customer tempcust = tempdb.Customers.Single(c => c.CustomerID == "ANTON"); foreach (Order o in tempcust.Orders) { deserializedOrders.Add(new Order { CustomerID = o.CustomerID, EmployeeID = o.EmployeeID, Freight = o.Freight, OrderDate = o.OrderDate, OrderID = o.OrderID, RequiredDate = o.RequiredDate, ShipAddress = o.ShipAddress, ShipCity = o.ShipCity, ShipName = o.ShipName, ShipCountry = o.ShipCountry, ShippedDate = o.ShippedDate, ShipPostalCode = o.ShipPostalCode, ShipRegion = o.ShipRegion, ShipVia = o.ShipVia }); } } using (NorthwindDataContext db2 = new NorthwindDataContext()) { //将第一个实体附加到当前数据上下文，以跟踪更改 //对Customer更新，不能写错 db2.Customers.Attach(deserializedC1); //更改所跟踪的实体 deserializedC1.Address = "123 First Ave"; //附加订单列表中的所有实体 db2.Orders.AttachAll(deserializedOrders); //将订单更新为属于其他客户 foreach (Order o in deserializedOrders) { o.CustomerID = "CHOPS"; } //在当前数据上下文中提交更改 db2.SubmitChanges(); } 语句描述:从另一个层中获取实体，使用Attach和AttachAll将反序列化后的实体附加到数据上下文，然后更新实体。更改被提交到数据库。 使用Attach更新和删除(Update and Delete with Attach) 说明:在不同的DataContext中，实现插入、更新、删除。看下面的一个例子: //通常，通过从其他层反序列化XML获取要附加的实体 //此示例使用 LoadWith 在一个查询中预先加载客户和订单， //并禁用延迟加载 Customer cust = null; using (NorthwindDataContext tempdb = new NorthwindDataContext()) { DataLoadOptions shape = new DataLoadOptions(); shape.LoadWith(c => c.Orders); //加载第一个客户实体及其订单 tempdb.LoadOptions = shape; tempdb.DeferredLoadingEnabled = false; cust = tempdb.Customers.First(x => x.CustomerID == "ALFKI"); } Order orderA = cust.Orders.First(); Order orderB = cust.Orders.First(x => x.OrderID > orderA.OrderID); using (NorthwindDataContext db2 = new NorthwindDataContext()) { //将第一个实体附加到当前数据上下文，以跟踪更改 db2.Customers.Attach(cust); //附加相关订单以进行跟踪; 否则将在提交时插入它们 db2.Orders.AttachAll(cust.Orders.ToList()); //更新客户的Phone. cust.Phone = "2345 5436"; //更新第一个订单OrderA的ShipCity. orderA.ShipCity = "Redmond"; //移除第二个订单OrderB. cust.Orders.Remove(orderB); //添加一个新的订单Order到客户Customer中. Order orderC = new Order() { ShipCity = "New York" }; cust.Orders.Add(orderC); //提交执行 db2.SubmitChanges(); } 语句描述:从一个上下文提取实体，并使用 Attach 和 AttachAll 附加来自其他上下文的实体，然后更新这两个实体，删除一个实体，添加另一个实体。更改被提交到数据库。 LINQ体验(10)——LINQ to SQL语句之开放式并发控制和事务 从今天开始继续这个系列。告诉大家一个好消息:微软于2月1日发布了Visual Studio Team System 2008 Team Suite简体中文版，您可以在这里下载Visual Studio Team System 2008 Team Suite简体中文版90 天 试用版。今天简单的学习下开放式并发控制和事务的内容，具体详细的内容现在可以参看MSDN了。 Simultaneous Changes开放式并发控制 下表介绍 LINQ to SQL 文档中涉及开放式并发的术语: 术语 说明 并发 两个或更多用户同时尝试更新同一数据库行的情形。 并发冲两个或更多用户同时尝试向一行的一列或多列提交冲突值的情形。 突 并发控用于解决并发冲突的技术。 制 开放式先调查其他事务是否已更改了行中的值，再允许提交更改的技术。相比之下，保守并发控式并发控制则是通过锁定记录来避免发生并发冲突。之所以称作开放式控制，是因制为它将一个事务干扰另一事务视为不太可能发生。 通过重新查询数据库刷新出现冲突的项，然后协调差异的过程。刷新对象时，LINQ to SQL 更改跟踪器会保留以下数据: 冲突解最初从数据库获取并用于更新检查的值 通过后续查询获得的新数据库值。 决 LINQ to SQL 随后会确定相应对象是否发生冲突(即它的一个或多个成员值是否已发 生更改)。如果此对象发生冲突，LINQ to SQL 下一步会确定它的哪些成员发生冲突。 LINQ to SQL 发现的任何成员冲突都会添加到冲突列表中。 在 LINQ to SQL 对象模型中，当以下两个条件都得到满足时，就会发生“开放式并发冲突”:客户端尝试向数据库提交更改;数据库中的一个或多个更新检查值自客户端上次读取它们以来已得到更新。 此冲突的解决过程包括查明对象的哪些成员发生冲突，然后决定您希望如何进行处理。 开放式并发(Optimistic Concurrency) 说明:这个例子中在你读取数据之前，另外一个用户已经修改并提交更新了这个数据，所以不会出现冲突。 //我们打开一个新的连接来模拟另外一个用户 NorthwindDataContext otherUser_db = new NorthwindDataContext(); var otherUser_product = otherUser_db.Products.First(p => p.ProductID == 1); otherUser_product.UnitPrice = 999.99M; otherUser_db.SubmitChanges(); //我们当前连接 var product = db.Products.First(p => p.ProductID == 1); product.UnitPrice = 777.77M; try { db.SubmitChanges();//当前连接执行成功 } catch (ChangeConflictException) { } 说明:我们读取数据之后，另外一个用户获取并提交更新了这个数据，这时，我们更新这个数据时，引起了一个并发冲突。系统发生回滚，允许你可以从数据库检索新更新的数据，并决定如何继续进行您自己的更新。 //当前用户 var product = db.Products.First(p => p.ProductID == 1); //我们打开一个新的连接来模拟另外一个用户 NorthwindDataContext otherUser_db = new NorthwindDataContext() ; var otherUser_product = otherUser_db.Products.First(p => p.ProductID == 1); otherUser_product.UnitPrice = 999.99M; otherUser_db.SubmitChanges(); //当前用户修改 product.UnitPrice = 777.77M; try { db.SubmitChanges(); } catch (ChangeConflictException) { //发生异常～ } Transactions事务 LINQ to SQL 支持三种事务模型，分别是: , 显式本地事务:调用 SubmitChanges 时，如果 Transaction 属性设 置为事务，则在同一事务的上下文中执行 SubmitChanges 调用。成功 执行事务后，要由您来提交或回滚事务。与事务对应的连接必须与用 于构造 DataContext 的连接匹配。如果使用其他连接，则会引发异常。 , 显式可分发事务:可以在当前 Transaction 的作用域中调用 LINQ to SQL API(包括但不限于 SubmitChanges)。LINQ to SQL 检测到调用是 在事务的作用域内，因而不会创建新的事务。在这种情况下， vbtecdlinq 还会避免关闭连接。您可以在此类事务的 上下文中执行查询和 SubmitChanges 操作。 , 隐式事务:当您调用 SubmitChanges 时，LINQ to SQL 会检查此调用 是否在 Transaction 的作用域内或者 Transaction 属性是否设置为由 用户启动的本地事务。如果这两个事务它均未找到，则 LINQ to SQL 启 动本地事务，并使用此事务执行所生成的 SQL 命令。当所有 SQL 命 令均已成功执行完毕时，LINQ to SQL 提交本地事务并返回。 1.Implicit(隐式) 说明:这个例子在执行SubmitChanges()操作时，隐式地使用了事务。因为在更新2种产品的库存数量时，第二个产品库存数量为负数了,违反了服务器上的 CHECK 约束。这导致了更新产品全部失败了，系统回滚到这个操作的初始状态。 try { Product prod1 = db.Products.First(p => p.ProductID == 4); Product prod2 = db.Products.First(p => p.ProductID == 5); prod1.UnitsInStock -= 3; prod2.UnitsInStock -= 5;//错误:库存数量的单位不能是负数 //要么全部成功要么全部失败 db.SubmitChanges(); } catch (System.Data.SqlClient.SqlException e) { //执行异常处理 } 2.Explicit(显式) 说明:这个例子使用显式事务。通过在事务中加入对数据的读取以防止出现开放式并发异常，显式事务可以提供更多的保护。如同上一个查询中，更新 prod2 的 UnitsInStock 字段将使该字段为负值，而这违反了数据库中的 CHECK 约束。这导致更新这两个产品的事务失败，此时将回滚所有更改。 using (TransactionScope ts = new TransactionScope()) { try { Product prod1 = db.Products.First(p => p.ProductID == 4); Product prod2 = db.Products.First(p => p.ProductID == 5); prod1.UnitsInStock -= 3; prod2.UnitsInStock -= 5;//错误:库存数量的单位不能是负数 db.SubmitChanges(); } catch (System.Data.SqlClient.SqlException e) { //执行异常处理 } } LINQ体验(11)——LINQ to SQL语句之Null语义和String/DateTime方法 在本系列中，主要介绍LINQ to SQL基础的东西，因为LINQ太强大了，它对我们平常使用不同的数据源有着不同的内容，其包括对于SQL Server ADO.NET 数数据库的LINQ to SQL;对于XML 文档的LINQ to XML;对于 据集的LINQ to DataSet;对于.NET 集合、文件、字符串等的LINQ to Objects。例外也出现了一些对LINQ支持的开源项目，例如LINQ to JSON，LINQ for NHibernate等等。在这个系列中，一些关于LINQ to SQL基础的东西就这么多了，这一篇用一些例子说明一下Null语义和String/DateTime方法。 Null语义 说明:下面第一个例子说明查询ReportsToEmployee为null的雇员。第二个例子使用 Nullable.HasValue查询雇员，其结果与第一个例子相同。在第三个例子中，使用 Nullable.Value来返回ReportsToEmployee 不为null的雇员的ReportsTo的值。 1.Null 查找不隶属于另一个雇员的所有雇员: var q = from e in db.Employees where e.ReportsToEmployee == null select e; 2.Nullable.HasValue 查找不隶属于另一个雇员的所有雇员: var q = from e in db.Employees where !e.ReportsTo.HasValue select e; 3.Nullable.Value 返回前者的EmployeeID 编号。请注意.Value 为可选: var q = from e in db.Employees where e.ReportsTo.HasValue select new { e.FirstName, e.LastName, ReportsTo = e.ReportsTo.Value }; 字符串/日期函数(String/Date Functions) LINQ to SQL支持以下String方法。但是不同的是默认情况下System.String 方法区分大小写。而SQL则不区分大小写。 1.字符串串联(String Concatenation) var q = from c in db.Customers select new { c.CustomerID, Location = c.City + ", " + c.Country }; 语句描述:这个例子使用+运算符在形成经计算得出的客户Location值过程中将字符串字段和字符串串联在一起。 2.String.Length var q = from p in db.Products where p.ProductName.Length < 10 select p; 语句描述:这个例子使用Length属性查找名称短于10个字符的所有产品。 3.String.Contains(substring) var q = from c in db.Customers where c.ContactName.Contains("Anders") select c; 语句描述:这个例子使用Contains方法查找所有其联系人姓名中包含“Anders”的客户。 4.String.IndexOf(substring) var q = from c in db.Customers select new { c.ContactName, SpacePos = c.ContactName.IndexOf(" ") }; 语句描述:这个例子使用IndexOf方法查找每个客户联系人姓名中出现第一个空格的位置。 5.String.StartsWith(prefix) var q = from c in db.Customers where c.ContactName.StartsWith("Maria") select c; 语句描述:这个例子使用StartsWith方法查找联系人姓名以“Maria”开头的客户。 6.String.EndsWith(suffix) var q = from c in db.Customers where c.ContactName.EndsWith("Anders") select c; 语句描述:这个例子使用EndsWith方法查找联系人姓名以“Anders”结尾的客户。 7.String.Substring(start) var q = from p in db.Products select p.ProductName.Substring(3); 语句描述:这个例子使用Substring方法返回产品名称中从第四个字母开始的部分。 8.String.Substring(start, length) var q = from e in db.Employees where e.HomePhone.Substring(6, 3) == "555" select e; 语句描述:这个例子使用Substring方法查找家庭电话号码第七位到第九位是“555”的雇员。 9.String.ToUpper() var q = from e in db.Employees select new { LastName = e.LastName.ToUpper(), e.FirstName }; 语句描述:这个例子使用ToUpper方法返回姓氏已转换为大写的雇员姓名。 10.String.ToLower() var q = from c in db.Categories select c.CategoryName.ToLower(); 语句描述:这个例子使用ToLower方法返回已转换为小写的类别名称。 11.String.Trim() var q = from e in db.Employees select e.HomePhone.Substring(0, 5).Trim(); 语句描述:这个例子使用Trim方法返回雇员家庭电话号码的前五位，并移除前导和尾随空格。 12.String.Insert(pos, str) var q = from e in db.Employees where e.HomePhone.Substring(4, 1) == ")" select e.HomePhone.Insert(5, ":"); 语句描述:这个例子使用Insert方法返回第五位为 ) 的雇员电话号码的序列，并在 ) 后面插入一个 :。 13.String.Remove(start) var q = from e in db.Employees where e.HomePhone.Substring(4, 1) == ")" select e.HomePhone.Remove(9); 语句描述:这个例子使用Remove方法返回第五位为 ) 的雇员电话号码的序列，并移除从第十个字符开始的所有字符。 14.String.Remove(start, length) var q = from e in db.Employees where e.HomePhone.Substring(4, 1) == ")" select e.HomePhone.Remove(0, 6); 语句描述:这个例子使用Remove方法返回第五位为 ) 的雇员电话号码的序列，并移除前六个字符。 15.String.Replace(find, replace) var q = from s in db.Suppliers select new { s.CompanyName, Country = s.Country .Replace("UK", "United Kingdom") .Replace("USA", "United States of America") }; 语句描述:这个例子使用 Replace 方法返回 Country 字段中UK 被替换为 United Kingdom 以及USA 被替换为 United States of America 的供应商信息。 日期函数 LINQ to SQL支持以下DateTime方法。但是，SQL Server和CLR的DateTime类型在范围和计时周期精度上不同，如下表。 类型 最小值 最大值 计时周期 0001 年 1 月 9999 年 12 月 100 毫微秒(0.0000001 System.DateTime 1 日 31 日 秒) 1753 年 1 月 9999 年 12 月 3.33„ 毫秒(0.0033333 T-SQL DateTime 1 日 31 日 秒) T-SQL 1900 年 1 月 2079 年 6 月 6 1 分钟(60 秒) SmallDateTime 1 日 日 CLR DateTime 类型与SQL Server类型相比，前者范围更大、精度更高。因此来自SQL Server的数据用CLR类型表示时，绝不会损失量值或精度。但如果反过来的话，则范围可能会减小，精度可能会降低;SQL Server日期不存在TimeZone概念，而在CLR中支持这个功能。 我们在LINQ to SQL查询使用以当地时间、UTC 或固定时间要自己执行转换。 下面用三个实例说明一下。 16.DateTime.Year var q = from o in db.Orders where o.OrderDate.Value.Year == 1997 select o; 语句描述:这个例子使用DateTime 的Year 属性查找1997 年下的订单。 17.DateTime.Month var q = from o in db.Orders where o.OrderDate.Value.Month == 12 select o; 语句描述:这个例子使用DateTime的Month属性查找十二月下的订单。 18.DateTime.Day var q = from o in db.Orders where o.OrderDate.Value.Day == 31 select o; 语句描述:这个例子使用DateTime的Day属性查找某月 31 日下的订单。 LINQ体验(12)——LINQ to SQL语句之对象标识和对象加载 对象标识 , 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是 引用此对象的同一实例。你更改一个变量后，可以通过另一个变量看 到这些更改。 , 关系数据库表中的行不具有唯一标识。由于每一行都具有唯一的主 键，因此任何两行都不会共用同一键值。 实际上，通常我们是将数据从数据库中提取出来放入另一层中，应用程序在该层对数据进行处理。这就是 LINQ to SQL 支持的模型。将数据作为行从数据库中提取出来时，你不期望表示相同数据的两行实际上对应于相 同的行实例。如果您查询特定客户两次，您将获得两行数据。每一行包含相同的信息。 对于对象。你期望在你反复向 DataContext 索取相同的信息时，它实际上会为你提供同一对象实例。你将它们设计为层次结构或关系图。你希望像检索实物一样检索它们，而不希望仅仅因为你多次索要同一内容而收到大量的复制实例。 在 LINQ to SQL 中，DataContext 管理对象标识。只要你从数据库中检索新行，该行就会由其主键记录到标识表中，并且会创建一个新的对象。只要您检索该行，就会将原始对象实例传递回应用程序。通过这种方式，DataContext 将数据库看到的标识(即主键)的概念转换成相应语言看到的标识(即实例)的概念。应用程序只看到处于第一次检索时的状态的对象。新数据如果不同，则会被丢弃。 LINQ to SQL 使用此方法来管理本地对象的完整性，以支持开放式更新。由于在最初创建对象后唯一发生的更改是由应用程序做出的，因此应用程序的意向是很明确的。如果在中间阶段外部某一方做了更改，则在调用 SubmitChanges() 时会识别出这些更改。 以上来自MSDN，的确，看了有点“正规”，下面我用两个例子说明一下。 对象缓存 在第一个示例中，如果我们执行同一查询两次，则每次都会收到对内存中同一对象的引用。很明显，cust1和cust2是同一个对象引用。 Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP"); Customer cust2 = db.Customers.First(c => c.CustomerID == "BONAP"); 下面的示例中，如果您执行返回数据库中同一行的不同查询，则您每次都会收到对内存中同一对象的引用。cust1和cust2是同一个对象引用，但是数据库查询了两次。 Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP"); Customer cust2 = ( from o in db.Orders where o.Customer.CustomerID == "BONAP" select o ) .First() .Customer; 对象加载 延迟加载 在查询某对象时，实际上你只查询该对象。不会同时自动获取这个对象。这就是延迟加载。 例如，您可能需要查看客户数据和订单数据。你最初不一定需要检索与每个客户有关的所有订单数据。其优点是你可以使用延迟加载将额外信息的检索操作延迟到你确实需要检索它们时再进行。请看下面的示例:检索出来CustomerID，就根据这个ID查询出OrderID。 var custs = from c in db.Customers where c.City == "Sao Paulo" select c; //上面的查询句法不会导致语句立即执行,仅仅是一个描述性的语句, 只有需要的时候才会执行它 foreach (var cust in custs) { foreach (var ord in cust.Orders) { //同时查看客户数据和订单数据 } } 语句描述:原始查询未请求数据，在所检索到各个对象的链接中导航如何能导致触发对数据库的新查询。 预先加载:LoadWith 方法 你如果想要同时查询出一些对象的集合的方法。LINQ to SQL 提供了 DataLoadOptions用于立即加载对象。方法包括: LoadWith 方法，用于立即加载与主目标相关的数据。 AssociateWith 方法，用于筛选为特定关系检索到的对象。 使用 LoadWith方法指定应同时检索与主目标相关的哪些数据。例如，如果你知道你需要有关客户的订单的信息，则可以使用 LoadWith 来确保在检索客户信息的同时检索订单信息。使用此方法可仅访问一次数据库，但同时获取两组信息。 在下面的示例中，我们通过设置DataLoadOptions，来指示DataContext在加载Customers的同时把对应的Orders一起加 载，在执行查询时会检索位于Sao Paulo的所有 Customers 的所有 Orders。这样一来，连续访问 Customer 对象的 Orders 属性不会触发新的数据库查询。在执行时生成的SQL语句使用了左连接。 NorthwindDataContext db = new NorthwindDataContext(); DataLoadOptions ds = new DataLoadOptions(); ds.LoadWith(p => p.Orders); db.LoadOptions = ds; var custs = ( from c in db2.Customers where c.City == "Sao Paulo" select c); foreach (var cust in custs) { foreach (var ord in cust.Orders) { Console.WriteLine("CustomerID {0} has an OrderID {1}.", cust.CustomerID, ord.OrderID); } } 语句描述:在原始查询过程中使用 LoadWith 请求相关数据，以便稍后在检索到的各个对象中导航时不需要对数据库进行额外的往返。 延迟加载:AssociateWith方法 使用 AssociateWith 方法指定子查询以限制检索的数据量。 在下面的示例中，AssociateWith 方法将检索的 Orders 限制为当天尚未装运的那些 Orders。如果没有此方法，则会检索所有 Orders，即使只需要一个子集。但是生成SQL语句会发现生成了很多SQL语句。 NorthwindDataContext db2 = new NorthwindDataContext(); DataLoadOptions ds = new DataLoadOptions(); ds.AssociateWith( p => p.Orders.Where(o => o.ShipVia > 1)); db2.LoadOptions = ds; var custs = from c in db2.Customers where c.City == "London" select c; foreach (var cust in custs) { foreach (var ord in cust.Orders) { foreach (var orderDetail in ord.OrderDetails) { //可以查询出cust.CustomerID, ord.OrderID, ord.ShipVia, //orderDetail.ProductID, orderDetail.Product.ProductName } } } 语句描述:原始查询未请求数据，在所检索到各个对象的链接中导航如何以触发对数据库的新查询而告终。此示例还说明在延迟加载关系对象时可以使用 Assoicate With 筛选它们。 预先加载:LoadWith方法和Associate With方法 这个例子说明:使用LoadWith方法来确保在检索客户信息的同时检索订单信息，在检索订单信息的同时检索订单详细信息， 仅仅访问一次数据库。即可以在一个查询中检索许多对象。使用Associate With方法来限制订单详细信息的排序规则。 NorthwindDataContext db2 = new NorthwindDataContext(); DataLoadOptions ds = new DataLoadOptions(); ds.LoadWith(p => p.Orders); ds.LoadWith(p => p.OrderDetails); ds.AssociateWith( p => p.OrderDetails.OrderBy(o => o.Quantity)); db2.LoadOptions = ds; var custs = ( from c in db2.Customers where c.City == "London" select c); foreach (var cust in custs) { foreach (var ord in cust.Orders) { foreach (var orderDetail in ord.OrderDetails) { //查询cust.CustomerID, ord.OrderID //orderDetail.ProductID, orderDetail.Quantity } } } 语句描述:在原始查询过程中使用 LoadWith 请求相关数据，以便稍后在检索到的各个对象中导航时此示例还说明在急切加载关系对象时可以使用 Assoicate With 对它们进行排序。 加载重写 这个例子在Category类里提供了一个LoadProducts分部方法。当产品的类别被加载的时候，就直接优先调用了LoadProducts方法来查询没有货源的产品。 private IEnumerable LoadProducts(Category category) { //在执行LINQ to SQL的时候，这个LoadProducts分部方法 //优先加载执行，这里用存储过程也可以. return this.Products .Where(p => p.CategoryID == category.CategoryID) .Where(p => !p.Discontinued); } 执行下面的查询时，利用上面方法返回的数据进行下面的操作: NorthwindDataContext db2 = new NorthwindDataContext(); DataLoadOptions ds = new DataLoadOptions(); ds.LoadWith(p => p.Products); db2.LoadOptions = ds; var q = ( from c in db2.Categories where c.CategoryID < 3 select c); foreach (var cat in q) { foreach (var prod in cat.Products) { //查询cat.CategoryID, prod.ProductID } } 语句描述:重写 Category 类中的分部方法 LoadProducts。加载某种类别的产品时，调用 LoadProducts 以加载此类别中未停产的产品。 LINQ体验(13)——LINQ to SQL语句之运算符转换和ADO.NET与LINQ to SQL 运算符转换 1.AsEnumerable:将类型转换为泛型 IEnumerable 使用 AsEnumerable 可返回类型化为泛型 IEnumerable 的参数。在此示例中，LINQ to SQL(使用默认泛型 Query)会尝试将查询转换为 SQL 并在服务器上执行。但 where 子句引用用户定义的客户端方法 (isValidProduct)，此方法无法转换为 SQL。 解决方法是指定 where 的客户端泛型 IEnumerable 实现以替换泛型 IQueryable。可通过调用 AsEnumerable运算符来执行此操作。 var q = from p in db.Products.AsEnumerable() where isValidProduct(p) select p; 语句描述:这个例子就是使用AsEnumerable以便使用Where的客户端IEnumerable实现，而不是默认的IQueryable将在服务器上转换为SQL并执行的默认Query实现。这很有必要，因为Where子句引用了用户定义的客户端方法isValidProduct，该方法不能转换为SQL。 2.ToArray:将序列转换为数组 使用 ToArray 可从序列创建数组。 var q = from c in db.Customers where c.City == "London" select c; Customer[] qArray = q.ToArray(); 语句描述:这个例子使用 ToArray 将查询直接计算为数组。 3.ToList:将序列转换为泛型列表 使用 ToList可从序列创建泛型列表。下面的示例使用 ToList直接将查询的计算结果放入泛型 List。 var q = from e in db.Employees where e.HireDate >= new DateTime(1994, 1, 1) select e; List qList = q.ToList(); 4.ToDictionary:将序列转化为字典 使用Enumerable.ToDictionary方法可以将序列转化为字典。TSource表示source中的元素的类型;TKey表示keySelector返回的键的类型。其返回 一个包含键和值的Dictionary。 var q = from p in db.Products where p.UnitsInStock <= p.ReorderLevel && !p.Discontinued select p; Dictionary qDictionary = q.ToDictionary(p => p.ProductID); foreach (int key in qDictionary.Keys) { Console.WriteLine(key); } 语句描述:这个例子使用 ToDictionary 将查询和键表达式直接键表达式直接计算为 Dictionary。 ADO.NET与LINQ to SQL LINQ to SQL 基于由 ADO.NET 提供程序模型提供的服务。因此，我们可以将 LINQ to SQL 代码与现有的 ADO.NET 应用程序混合在一起，将当前 ADO.NET 解决方案迁移到 LINQ to SQL。 1.连接 在创建 LINQ to SQL DataContext 时，可以提供现有 ADO.NET 连接。对 DataContext 的所有操作(包括查询)都使用所提供的这个连接。如果此连接已经打开，则在您使用完此连接时，LINQ to SQL 会保持它的打开状 Connection 属性自态不变。我们始终可以访问此连接，另外还可以使用 行关闭它。 //新建一个标准的ADO.NET连接: SqlConnection nwindConn = new SqlConnection(connString); nwindConn.Open(); // ... 其它的ADO.NET数据操作代码... // //利用现有的ADO.NET连接来创建一个DataContext: Northwind interop_db = new Northwind(nwindConn); var orders = from o in interop_db.Orders where o.Freight > 500.00M select o; //返回Freight>500.00M的订单 nwindConn.Close(); 语句描述:这个例子使用预先存在的ADO.NET连接创建Northwind对象，本例中的查询返回运费至少为500.00 的所有订单。 2.事务 当我们已经启动了自己的数据库事务并且我们希望DataContext 包含在内时，我们可以向 DataContext 提供此事务。 通过 .NET Framework 创建事务的首选方法是使用 TransactionScope 对象。通过使用此方法，我们可以创建跨数据库及其他驻留在内存中的资源管理器执行的分布式事务。事务范围几乎不需要资源就可以启动。它们仅在事务范围内存在多个连接时才将自身提升为分布式事务。 using (TransactionScope ts = new TransactionScope()) { db.SubmitChanges(); ts.Complete(); } 注意:不能将此方法用于所有数据库。例如，SqlClient 连接在针对 SQL Server 2000 服务器使用时无法提升系统事务。它采取的方法是，只要它发现有使用事务范围的情况，它就会自动向完整的分布式事务登记。 下面用一个例子说明一下事务的使用方法。在这里，也说明了重用 ADO.NET 命令和 DataContext 之间的同一连接。 var q = from p in db.Products where p.ProductID == 3 select p; //使用LINQ to SQL查询出来 //新建一个标准的ADO.NET连接: SqlConnection nwindConn = new SqlConnection(connString); nwindConn.Open(); //利用现有的ADO.NET连接来创建一个DataContext: Northwind interop_db = new Northwind(nwindConn); SqlTransaction nwindTxn = nwindConn.BeginTransaction(); try { SqlCommand cmd = new SqlCommand("UPDATE Products SET" +"QuantityPerUnit = 'single item' WHERE ProductID = 3"); cmd.Connection = nwindConn; cmd.Transaction = nwindTxn; cmd.ExecuteNonQuery(); interop_db.Transaction = nwindTxn; Product prod1 = interop_db.Products.First(p => p.ProductID == 4); Product prod2 = interop_db.Products.First(p => p.ProductID == 5); prod1.UnitsInStock -= 3; prod2.UnitsInStock -= 5;//这有一个错误，不能为负数 interop_db.SubmitChanges(); nwindTxn.Commit(); } catch (Exception e) { //如果有一个错误，所有的操作回滚 Console.WriteLine(e.Message); } nwindConn.Close(); 语句描述:这个例子使用预先存在的 ADO.NET 连接创建 Northwind 对象，然后与此对象共享一个 ADO.NET 事务。此事务既用于通过 ADO.NET 连接执行 SQL 命令，又用于通过 Northwind 对象提交更改。当事务因违反 CHECK 约束而中止时，将回滚所有更改，包括通过 SqlCommand 做出的更改，以及通过Northwind 对象做出的更改。 3.直接执行 SQL语句 1.直接执行SQL查询 如果 LINQ to SQL 查询不足以满足专门任务的需要，我们可以使用 ExecuteQuery 方法来执行 SQL 查询，然后将查询的结果直接转换成对象。 var products = db.ExecuteQuery( "SELECT [Product List].ProductID,"+ "[Product List].ProductName " + "FROM Products AS [Product List] " + "WHERE [Product List].Discontinued = 0 " + "ORDER BY [Product List].ProductName;" ); 语句描述:这个例子使用ExecuteQuery执行任意 SQL 查询，并将所得的行映射为 Product 对象的序列。 2.直接执行SQL命令 采用DataContext 连接时，可以使用ExecuteCommand来执行不返回对象的 SQL 命令。 db.ExecuteCommand ("UPDATE Products SET UnitPrice = UnitPrice + 1.00"); 语句描述:使用ExecuteCommand执行任意SQL命令，本例中为将所有产品单价提高 1.00 的批量更新。 LINQ体验(14)——LINQ to SQL语句之存储过程 存储过程 在我们编写程序中，往往需要一些存储过程，在LINQ to SQL中怎么使用呢,也许比原来的更简单些。下面我们以NORTHWND.MDF数据库中自带的几个存储过程来理解一下。 1.标量返回 在数据库中，有名为Customers Count By Region的存储过程。该存储过程返回顾客所在"WA"区域的数量。 ALTER PROCEDURE [dbo].[NonRowset] (@param1 NVARCHAR(15)) AS BEGIN SET NOCOUNT ON; DECLARE @count int SELECT @count = COUNT(*)FROM Customers WHERECustomers.Region = @Param1 RETURN @count END 我们只要把这个存储过程拖到O/R设计器内，它自动生成了以下代码段: [Function(Name = "dbo.[Customers Count By Region]")] public int Customers_Count_By_Region([Parameter (DbType = "NVarChar(15)")] string param1) { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), param1); return ((int)(result.ReturnValue)); } 我们需要时，直接调用就可以了，例如: int count = db.CustomersCountByRegion("WA"); Console.WriteLine(count); 语句描述:这个实例使用存储过程返回在“WA”地区的客户数。 2.单一结果集 从数据库中返回行集合，并包含用于筛选结果的输入参数。 当我们执行 返回行集合的存储过程时，会用到结果类，它存储从存储过程中返回的结果。 下面的示例表示一个存储过程，该存储过程返回客户行并使用输入参数来仅返回将“London”列为客户城市的那些行的固定几列。 ALTER PROCEDURE [dbo].[Customers By City] -- Add the parameters for the stored procedure here (@param1 NVARCHAR(20)) AS BEGIN -- SET NOCOUNT ON added to prevent extra result sets from -- interfering with SELECT statements. SET NOCOUNT ON; SELECT CustomerID, ContactName, CompanyName, City from Customers as c where c.City=@param1 END 拖到O/R设计器内，它自动生成了以下代码段: [Function(Name="dbo.[Customers By City]")] public ISingleResult Customers_By_City( [Parameter(DbType="NVarChar(20)")] string param1) { IExecuteResult result = this.ExecuteMethodCall(this, ( (MethodInfo)(MethodInfo.GetCurrentMethod())), param1); return ((ISingleResult) (result.ReturnValue)); } 我们用下面的代码调用: ISingleResult result = db.Customers_By_City("London"); foreach (Customers_By_CityResult cust in result) { Console.WriteLine("CustID={0}; City={1}", cust.CustomerID, cust.City); } 语句描述:这个实例使用存储过程返回在伦敦的客户的 CustomerID和City。 3.多个可能形状的单一结果集 当存储过程可以返回多个结果形状时，返回类型无法强类型化为单个投影形状。尽管 LINQ to SQL 可以生成所有可能的投影类型，但它无法获知 将以何种顺序返回它们。 ResultTypeAttribute 属性适用于返回多个结 果类型的存储过程，用以指定该过程可以返回的类型的集合。 在下面的 SQL 代码示例中，结果形状取决于输入(param1 = 1或param1 = 2)。我们不知道先返回哪个投影。 ALTER PROCEDURE [dbo].[SingleRowset_MultiShape] -- Add the parameters for the stored procedure here (@param1 int ) AS BEGIN -- SET NOCOUNT ON added to prevent extra result sets from -- interfering with SELECT statements. SET NOCOUNT ON; if(@param1 = 1) SELECT * from Customers as c where c.Region = 'WA' else if (@param1 = 2) SELECT CustomerID, ContactName, CompanyName from Customers as c where c.Region = 'WA' END 拖到O/R设计器内，它自动生成了以下代码段: [Function(Name="dbo.[Whole Or Partial Customers Set]")] public ISingleResult Whole_Or_Partial_Customers_Set([Parameter(DbType="Int")] System.Nullable param1) { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), param1); return ((ISingleResult) (result.ReturnValue)); } 但是，VS2008会把多结果集存储过程识别为单结果集的存储过程，默认生成的代码我们要手动修改一下，要求返回多个结果集，像这样: [Function(Name="dbo.[Whole Or Partial Customers Set]")] [ResultType(typeof(WholeCustomersSetResult))] [ResultType(typeof(PartialCustomersSetResult))] public IMultipleResults Whole_Or_Partial_Customers_Set([Parameter (DbType="Int")] System.Nullable param1) { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), param1); return ((IMultipleResults)(result.ReturnValue)); } 我们分别定义了两个分部类，用于指定返回的类型。 WholeCustomersSetResult类 如下:(点击展开) 代码在这里展开PartialCustomersSetResult类 如下:(点击展开) 代码在这里展开这样就可以使用了，下面代码直接调用，分别返回各自的结果集合。 //返回全部Customer结果集 IMultipleResults result = db.Whole_Or_Partial_Customers_Set(1); IEnumerable shape1 = result.GetResult(); foreach (WholeCustomersSetResult compName in shape1) { Console.WriteLine(compName.CompanyName); } //返回部分Customer结果集 result = db.Whole_Or_Partial_Customers_Set(2); IEnumerable shape2 = result.GetResult(); foreach (PartialCustomersSetResult con in shape2) { Console.WriteLine(con.ContactName); } 语句描述:这个实例使用存储过程返回“WA”地区中的一组客户。返回的结果集形状取决于传入的参数。如果参数等于 1，则返回所有客户属性。 如果参数等于 2，则返回ContactName属性。 4.多个结果集 这种存储过程可以生成多个结果形状，但我们已经知道结果的返回顺序。 下面是一个按顺序返回多个结果集的存储过程Get Customer And Orders。 返回顾客ID为"SEVES"的顾客和他们所有的订单。 ALTER PROCEDURE [dbo].[Get Customer And Orders] (@CustomerID nchar(5)) -- Add the parameters for the stored procedure here AS BEGIN -- SET NOCOUNT ON added to prevent extra result sets from -- interfering with SELECT statements. SET NOCOUNT ON; SELECT * FROM Customers AS c WHERE c.CustomerID = @CustomerID SELECT * FROM Orders AS o WHERE o.CustomerID = @CustomerID END 拖到设计器代码如下: [Function(Name="dbo.[Get Customer And Orders]")] public ISingleResult Get_Customer_And_Orders([Parameter(Name="CustomerID", DbType="NChar(5)")] string customerID) { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID); return ((ISingleResult) (result.ReturnValue)); } 同样，我们要修改自动生成的代码: [Function(Name="dbo.[Get Customer And Orders]")] [ResultType(typeof(CustomerResultSet))] [ResultType(typeof(OrdersResultSet))] public IMultipleResults Get_Customer_And_Orders ([Parameter(Name="CustomerID",DbType="NChar(5)")] string customerID) { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID); return ((IMultipleResults)(result.ReturnValue)); } 同样，自己手写类，让其存储过程返回各自的结果集。 CustomerResultSet类 代码在这里展开OrdersResultSet类 代码在这里展开这时，只要调用就可以了。 IMultipleResults result = db.Get_Customer_And_Orders("SEVES"); //返回Customer结果集 IEnumerable customer = result.GetResult(); //返回Orders结果集 IEnumerable orders = result.GetResult(); //在这里，我们读取CustomerResultSet中的数据 foreach (CustomerResultSet cust in customer) { Console.WriteLine(cust.CustomerID); } 语句描述:这个实例使用存储过程返回客户“SEVES”及其所有订单。 5.带输出参数 LINQ to SQL 将输出参数映射到引用参数，并且对于值类型，它将参数声明为可以为 null。 下面的示例带有单个输入参数(客户 ID)并返回一个输出参数(该客户的总销售额)。 ALTER PROCEDURE [dbo].[CustOrderTotal] @CustomerID nchar(5), @TotalSales money OUTPUT AS SELECT @TotalSales = SUM(OD.UNITPRICE*(1-OD.DISCOUNT) * OD.QUANTITY) FROM ORDERS O, "ORDER DETAILS" OD where O.CUSTOMERID = @CustomerID AND O.ORDERID = OD.ORDERID 把这个存储过程拖到设计器中，图片如下: 其生成代码如下: [Function(Name="dbo.CustOrderTotal")] public int CustOrderTotal( [Parameter(Name="CustomerID", DbType="NChar(5)")]string customerID, [Parameter(Name="TotalSales", DbType="Money")] ref System.Nullable totalSales) { IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID, totalSales); totalSales = ((System.Nullable) (result.GetParameterValue(1))); return ((int)(result.ReturnValue)); } 我们使用下面的语句调用此存储过程:注意:输出参数是按引用传递的，以支持参数为“in/out”的方案。在这种情况下，参数仅为“out”。 decimal? totalSales = 0; string customerID = "ALFKI"; db.CustOrderTotal(customerID, ref totalSales); Console.WriteLine("Total Sales for Customer '{0}' = {1:C}", customerID, totalSales); 语句描述:这个实例使用返回 Out 参数的存储过程。 好了，就说到这里了，其增删改操作同理。相信大家通过这5个实例理解了存储过程。 LINQ体验(15)——LINQ to SQL语句之用户定义函数 用户定义函数 我们可以在LINQ to SQL中使用用户定义函数。只要把用户定义函数拖到O/R设计器中，LINQ to SQL自动使用FunctionAttribute属性和ParameterAttribute属性(如果需要)将其函数指定为方法。这时，我们只需简单 调用即可。 在这里注意:使用用户定义函数的时候必须满足以下形式之一，否则会出现InvalidOperationException异常情况。 , 具有正确映射属性的方法调用的函数。这里使用FunctionAttribute 属性和 ParameterAttribute属性。 , 特定于LINQ to SQL的静态SQL方法。 , .NET Framework方法支持的函数。 下面介绍几个例子: 1.在Select中使用用户定义的标量函数 所谓标量函数是指返回在 RETURNS 子句中定义的类型的单个数据值。可以使用所有标量数据类型，包括 bigint 和 sql_variant。不支持 timestamp 数据类型、用户定义数据类型和非标量类型(如 table 或 cursor)。在 BEGIN...END 块中定义的函数主体包含返回该值的 Transact-SQL 语句系列。返回类型可以是除 text、ntext、image、cursor 和 timestamp 之外的任何数据类型。 我们在系统自带的NORTHWND.MDF数据库中，有3个自定义函数，这里使用 TotalProductUnitPriceByCategory，其代码如下: ALTER FUNCTION [dbo].[TotalProductUnitPriceByCategory] (@categoryID int) RETURNS Money AS BEGIN -- Declare the return variable here DECLARE @ResultVar Money -- Add the T-SQL statements to compute the return value here SELECT @ResultVar = (Select SUM(UnitPrice) from Products where CategoryID = @categoryID) -- Return the result of the function RETURN @ResultVar END 我们将其拖到设计器中，LINQ to SQL通过使用 FunctionAttribute 属性将类中定义的客户端方法映射到用户定义的函数。请注意，这个方法体会构造一个捕获方法调用意向的表达式，并将该表达式传递给 DataContext 进行转换和执行。 [Function(Name="dbo.TotalProductUnitPriceByCategory", IsComposable=true)] public System.Nullable TotalProductUnitPriceByCategory( [Parameter(DbType="Int")] System.Nullable categoryID) { return ((System.Nullable)(this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), categoryID) .ReturnValue)); } 我们使用时，可以用以下代码来调用: var q = from c in db.Categories select new { c.CategoryID, TotalUnitPrice = db.TotalProductUnitPriceByCategory(c.CategoryID) }; 这时，LINQ to SQL自动生成SQL语句如下: SELECT [t0].[CategoryID], CONVERT(Decimal(29,4), [dbo].[TotalProductUnitPriceByCategory]([t0].[CategoryID])) AS [TotalUnitPrice] FROM [dbo].[Categories] AS [t0] 2.在Where从句中使用用户定义的标量函数 这个例子使用方法同上一个例子原理基本相同了， MinUnitPriceByCategory自定义函数如下: ALTER FUNCTION [dbo].[MinUnitPriceByCategory] (@categoryID INT ) RETURNS Money AS BEGIN -- Declare the return variable here DECLARE @ResultVar Money -- Add the T-SQL statements to compute the return value here SELECT @ResultVar = MIN(p.UnitPrice) FROM Products as p WHERE p.CategoryID = @categoryID -- Return the result of the function RETURN @ResultVar END 拖到设计器中，生成代码如下: [Function(Name="dbo.MinUnitPriceByCategory", IsComposable=true)] public System.Nullable MinUnitPriceByCategory( [Parameter(DbType="Int")] System.Nullable categoryID) { return ((System.Nullable)(this.ExecuteMethodCall( this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), categoryID).ReturnValue)); } 这时可以使用了:注意这里在 LINQ to SQL 查询中，对生成的用户定义函数方法MinUnitPriceByCategory的内联调用。此函数不会立即执行，这是因为查询会延迟执行。延迟执行的查询中包含的函数直到此查询执行时才会执行。为此查询生成的 SQL 会转换成对数据库中用户定义函数的调用(请参见此查询后面的生成的 SQL语句)，当在查询外部调用这个函数时，LINQ to SQL 会用方法调用表达式创建一个简单查询并执行。 var q = from p in db.Products where p.UnitPrice == db.MinUnitPriceByCategory(p.CategoryID) select p; 它自动生成的SQL语句如下: SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID],[t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0].[ReorderLevel], [t0].[Discontinued]FROM [dbo].[Products] AS [t0] WHERE [t0].[UnitPrice] = [dbo].[MinUnitPriceByCategory]([t0].[CategoryID]) 3.使用用户定义的表值函数 表值函数返回单个行集(与存储过程不同，存储过程可返回多个结果形 状)。由于表值函数的返回类型为 Table，因此在 SQL 中可以使用表的 任何地方均可以使用表值函数。此外，您还可以完全像处理表那样来处理 表值函数。 下面的 SQL 用户定义函数显式声明其返回一个 TABLE。因此，隐式定义 了所返回的行集结构。 ALTER FUNCTION [dbo].[ProductsUnderThisUnitPrice] (@price Money ) RETURNS TABLE AS RETURN SELECT * FROM Products as P Where p.UnitPrice < @price 拖到设计器中，LINQ to SQL 按如下方式映射此函数: [Function(Name="dbo.ProductsUnderThisUnitPrice", IsComposable=true)] public IQueryable ProductsUnderThisUnitPrice([Parameter(DbType="Money")] System.Nullable price) { return this.CreateMethodCallQuery (this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), price); } 这时我们小小的修改一下Discontinued属性为可空的bool类型。 private System.Nullable _Discontinued; public System.Nullable Discontinued { } 我们可以这样调用使用了: var q = from p in db.ProductsUnderThisUnitPrice(10.25M) where !(p.Discontinued ?? false) select p; 其生成SQL语句如下: SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID], [t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder], [t0].[ReorderLevel], [t0].[Discontinued] FROM [dbo].[ProductsUnderThisUnitPrice](@p0) AS [t0] WHERE NOT ((COALESCE([t0].[Discontinued],@p1)) = 1) -- @p0: Input Money (Size = 0; Prec = 19; Scale = 4) [10.25] -- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0] 4.以联接方式使用用户定义的表值函数 我们利用上面的ProductsUnderThisUnitPrice用户定义函数，在 LINQ to SQL 中，调用如下: var q = from c in db.Categories join p in db.ProductsUnderThisUnitPrice(8.50M) on c.CategoryID equals p.CategoryID into prods from p in prods select new { c.CategoryID, c.CategoryName, p.ProductName, p.UnitPrice }; 其生成的 SQL 代码说明对此函数返回的表执行联接。 SELECT [t0].[CategoryID], [t0].[CategoryName], [t1].[ProductName], [t1].[UnitPrice] FROM [dbo].[Categories] AS [t0] CROSS JOIN [dbo].[ProductsUnderThisUnitPrice](@p0) AS [t1] WHERE ([t0].[CategoryID]) = [t1].[CategoryID] -- @p0: Input Money (Size = 0; Prec = 19; Scale = 4) [8.50] LINQ体验(16)——LINQ to SQL语句之DataContext DataContext DataContext作为LINQ to SQL框架的主入口点，为我们提供了一些方法和属性，本文用几个例子说明DataContext几个典型的应用。 创建和删除数据库 CreateDatabase方法用于在服务器上创建数据库。 DeleteDatabase方法用于删除由DataContext连接字符串标识的数据库。 数据库的名称有以下方法来定义: 如果数据库在连接字符串中标识，则使用该连接字符串的名称。 如果存在DatabaseAttribute属性(Attribute)，则将其Name属性(Property)用作数据库的名称。 如果连接字符串中没有数据库标记，并且使用强类型的DataContext，则会检查与DataContext继承类名称相同的数据库。如果使用弱类型的DataContext，则会引发异常。 如果已通过使用文件名创建了DataContext，则会创建与该文件名相对应的数据库。 我们首先用实体类描述关系数据库表和列的结构的属性。再调用 DataContext的CreateDatabase方法，LINQ to SQL会用我们的定义的实 体类结构来构造一个新的数据库实例。还可以通过使用 .mdf 文件或只使 用目录名(取决于连接字符串)，将 CreateDatabase与SQL Server一起 使用。LINQ to SQL使用连接字符串来定义要创建的数据库和作为数据库 创建位置的服务器。 说了这么多，用一段实例说明一下吧～ 首先，我们新建一个NewCreateDB类用于创建一个名为NewCreateDB.mdf的新数据库，该数据库有一个Person表，有三个字段，分别为PersonID、 PersonName、Age。(点击展开代码) 代码在这里展开接下来的一段代码先创建一个数据库，在调用 CreateDatabase后，新的数据库就会存在并且会接受一般的查询和命令。 接着插入一条记录并且查询。最后删除这个数据库。 //1.新建一个临时文件夹来存放新建的数据库 string userTempFolder = Environment.GetEnvironmentVariable ("SystemDrive") + @"\YJingLee"; Directory.CreateDirectory(userTempFolder); //2.新建数据库NewCreateDB string userMDF = System.IO.Path.Combine(userTempFolder, @"NewCreateDB.mdf"); string connStr = String.Format(@"Data Source=.\SQLEXPRESS; AttachDbFilename={0};Integrated Security=True; Connect Timeout=30;User Instance=True; Integrated Security = SSPI;", userMDF); NewCreateDB newDB = new NewCreateDB(connStr); newDB.CreateDatabase(); //3.插入数据并查询 var newRow = new Person { PersonID = 1, PersonName = "YJingLee", Age = 22 }; newDB.Persons.InsertOnSubmit(newRow); newDB.SubmitChanges(); var q = from x in newDB.Persons select x; //4.删除数据库 newDB.DeleteDatabase(); //5.删除临时目录 Directory.Delete(userTempFolder); 数据库验证 DatabaseExists方法用于尝试通过使用DataContext中的连接打开数据库，如果成功返回true。 下面代码说明是否存在Northwind数据库和NewCreateDB数据库 。 //检测Northwind数据库是否存在 if (db.DatabaseExists()) Console.WriteLine("Northwind数据库存在"); else Console.WriteLine("Northwind数据库不存在"); //检测NewCreateDB数据库是否存在 string userTempFolder = Environment.GetEnvironmentVariable("Temp"); string userMDF = System.IO.Path.Combine(userTempFolder, @"NewCreateDB.mdf"); NewCreateDB newDB = new NewCreateDB(userMDF); if (newDB.DatabaseExists()) Console.WriteLine("NewCreateDB数据库存在"); else Console.WriteLine("NewCreateDB数据库不存在"); 数据库更改 SubmitChanges方法计算要插入、更新或删除的已修改对象的集，并执行相应命令以实现对数据库的更改。 无论对象做了多少项更改，都只是在更改内存中的副本。并未对数据库中的实际数据做任何更改。直到对DataContext显式调用 SubmitChanges，所做的更改才会传输到服务器。调用时，DataContext会设法将我们所做的更改转换为等效的SQL命令。我们也可以使 用自己的自定义逻辑来重写这些操作，但提交顺序是由DataContext的一项称作“更改处理器”的服务来协调的。事件的顺序如下: 1. 当调用SubmitChanges时，LINQ to SQL会检查已知对象的集合以确 定新实例是否已附加到它们。如果已附加，这些新实例将添加到被跟踪 对象的集合。 2. 所有具有挂起更改的对象将按照它们之间的依赖关系排序成一个对 象序列。如果一个对象的更改依赖于其他对象，则这个对象将排在其依 赖项之后。 3. 在即将传输任何实际更改时，LINQ to SQL会启动一个事务来封装由 各条命令组成的系列。 4. 对对象的更改会逐个转换为SQL命令，然后发送到服务器。 如果数据库检测到任何错误，都会造成提交进程停止并引发异常。将回滚对数据库的所有更改，就像未进行过提交一样。DataContext 仍具有所有更改的完整记录。 下面代码说明的是在数据库中查询CustomerID为ALFKI的顾客，然后修改其公司名称，第一次更新并调用SubmitChanges()方法，第二次更新了数据但并未调用SubmitChanges()方法。 //查询 Customer cust = db.Customers.First(c => c.CustomerID == "ALFKI"); //更新数据并调用SubmitChanges()方法 cust.CompanyName = "YJingLee's Blog"; db.SubmitChanges(); //更新数据没有调用SubmitChanges()方法 cust.CompanyName = ""; 动态查询 使用动态查询，这个例子用CreateQuery()方法创建一个IQueryable类型表达式输出查询的语句。这里给个例子说明一下。有关动态查询具体内容，下一篇介绍。 var c1 = Expression.Parameter(typeof(Customer), "c"); PropertyInfo City = typeof(Customer).GetProperty("City"); var pred = Expression.Lambda>( Expression.Equal( Expression.Property(c1, City), Expression.Constant("Seattle") ), c1 ); IQueryable custs = db.Customers; Expression expr = Expression.Call(typeof(Queryable), "Where", new Type[] { custs.ElementType }, custs.Expression, pred); IQueryable q = db.Customers.AsQueryable(). Provider.CreateQuery(expr); 日志 Log属性用于将SQL查询或命令打印到TextReader。此方法对了解 LINQ to SQL 功能和调试特定的问题可能很有用。 下面的示例使用Log属性在SQL代码执行前在控制台窗口中显示此代码。我们可以将此属性与查询、插入、更新和删除命令一起使用。 //关闭日志功能 //db.Log = null; //使用日志功能:日志输出到控制台窗口 db.Log = Console.Out; var q = from c in db.Customers where c.City == "London" select c; //日志输出到文件 StreamWriter sw = new StreamWriter(Server.MapPath("log.txt"), true); db.Log = sw; var q = from c in db.Customers where c.City == "London" select c; sw.Close(); LINQ体验(17)——LINQ to SQL语句之动态查询 高级特性 本文介绍LINQ的高级特性，其包括大家都关心的动态查询的用法，另外简单提下ID标识这个知识。 动态查询 有这样一个场景:应用程序可能会提供一个用户界面，用户可以使用该用户界面指定一个或多个谓词来筛选数据。这种情况在编译时不知道查询的细节，动态查询将十分有用。 在LINQ中，Lambda表达式是许多标准查询运算符的基础，编译器创建lambda表达式以捕获基础查询方法(例如 Where、Select、Order By、Take While 以及其他方法)中定义的计算。表达式目录树用于针对数据源的结构化查询，这些数据源实现IQueryable。例如，LINQ to SQL 提供程序实现 IQueryable接口，用于查询关系数据存储。C#和Visual Basic编译器会针对此类数据源的查询编译为代码，该代码在运行时将生成一个表达式目录树。然后，查询提供程序可以遍历表达式目录树数据结构，并将其转换为适合于数据源的查询语言。 表达式目录树在LINQ中用于表示分配给类型为Expression 的变量的Lambda表达式。还可用于创建动态LINQ查询。 System.Linq.Expressions命名空间提供用于手动生成表达式目录树的API。Expression类包含创建特定类型的表达式目录树 节点的静态工厂方法，例如，ParameterExpression(表示一个已命名的参数表达式)或 MethodCallExpression(表示一个方法调用)。编译器生成的表达式目录树的根始终在类型 Expression的节点中，其中TDelegate是包含至多五个输入参数的任何TDelegate委托;也就是 说，其根节点是表示一个lambda表达式。 下面几个例子描述如何使用表达式目录树来创建动态LINQ查询。 1.Select 下面例子说明如何使用表达式树依据 IQueryable 数据源构造一个动态查询，查询出每个顾客的ContactName，并用GetCommand方法获取其生成SQL语句。 //依据IQueryable数据源构造一个查询 IQueryable custs = db.Customers; //组建一个表达式树来创建一个参数 ParameterExpression param = Expression.Parameter(typeof(Customer), "c"); //组建表达式树:c.ContactName Expression selector = Expression.Property(param, typeof(Customer).GetProperty("ContactName")); Expression pred = Expression.Lambda(selector, param); //组建表达式树:Select(c=>c.ContactName) Expression expr = Expression.Call(typeof(Queryable), "Select", new Type[] { typeof(Customer), typeof(string) }, Expression.Constant(custs), pred); //使用表达式树来生成动态查询 IQueryable query = db.Customers.AsQueryable() .Provider.CreateQuery(expr); //使用GetCommand方法获取SQL语句 System.Data.Common.DbCommand cmd = db.GetCommand(query); Console.WriteLine(cmd.CommandText); 生成的SQL语句为: SELECT [t0].[ContactName] FROM [dbo].[Customers] AS [t0] 2.Where 下面一个例子是“搭建”Where用法来动态查询城市在伦敦的顾客。 IQueryable custs = db.Customers; //创建一个参数c ParameterExpression param = Expression.Parameter(typeof(Customer), "c"); //c.City=="London" Expression left = Expression.Property(param, typeof(Customer).GetProperty("City")); Expression right = Expression.Constant("London"); Expression filter = Expression.Equal(left, right); Expression pred = Expression.Lambda(filter, param); //Where(c=>c.City=="London") Expression expr = Expression.Call(typeof(Queryable), "Where", new Type[] { typeof(Customer) }, Expression.Constant(custs), pred); //生成动态查询 IQueryable query = db.Customers.AsQueryable() .Provider.CreateQuery(expr); 生成的SQL语句为: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] = @p0 -- @p0: Input NVarChar (Size = 6; Prec = 0; Scale = 0) [London] 3.OrderBy 本例既实现排序功能又实现了过滤功能。 IQueryable custs = db.Customers; //创建一个参数c ParameterExpression param = Expression.Parameter(typeof(Customer), "c"); //c.City=="London" Expression left = Expression.Property(param, typeof(Customer).GetProperty("City")); Expression right = Expression.Constant("London"); Expression filter = Expression.Equal(left, right); Expression pred = Expression.Lambda(filter, param); //Where(c=>c.City=="London") MethodCallExpression whereCallExpression = Expression.Call( typeof(Queryable), "Where", new Type[] { typeof(Customer) }, Expression.Constant(custs), pred); //OrderBy(ContactName => ContactName) MethodCallExpression orderByCallExpression = Expression.Call( typeof(Queryable), "OrderBy", new Type[] { typeof(Customer), typeof(string) }, whereCallExpression, Expression.Lambda(Expression.Property (param, "ContactName"), param)); //生成动态查询 IQueryable query = db.Customers.AsQueryable() .Provider.CreateQuery(orderByCallExpression); 下面一张截图显示了怎么动态生成动态查询的过程 生成的SQL语句为: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax] FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] = @p0 ORDER BY [t0].[ContactName] -- @p0: Input NVarChar (Size = 6; Prec = 0; Scale = 0) [London] 4.Union 下面的例子使用表达式树动态查询顾客和雇员同在的城市。 //e.City IQueryable custs = db.Customers; ParameterExpression param1 = Expression.Parameter(typeof(Customer), "e"); Expression left1 = Expression.Property(param1, typeof(Customer).GetProperty("City")); Expression pred1 = Expression.Lambda(left1, param1); //c.City IQueryable employees = db.Employees; ParameterExpression param2 = Expression.Parameter(typeof(Employee), "c"); Expression left2 = Expression.Property(param2, typeof(Employee).GetProperty("City")); Expression pred2 = Expression.Lambda(left2, param2); //Select(e=>e.City) Expression expr1 = Expression.Call(typeof(Queryable), "Select", new Type[] { typeof(Customer), typeof(string) }, Expression.Constant(custs), pred1); //Select(c=>c.City) Expression expr2 = Expression.Call(typeof(Queryable), "Select", new Type[] { typeof(Employee), typeof(string) }, Expression.Constant(employees), pred2); //生成动态查询 IQueryable q1 = db.Customers.AsQueryable() .Provider.CreateQuery(expr1); IQueryable q2 = db.Employees.AsQueryable() .Provider.CreateQuery(expr2); //并集 var q3 = q1.Union(q2); 生成的SQL语句为: SELECT [t2].[City] FROM ( SELECT [t0].[City] FROM [dbo].[Customers] AS [t0] UNION SELECT [t1].[City] FROM [dbo].[Employees] AS [t1] ) AS [t2] ID标识 在前面这一点没有说到，在这里作为高级特性单独说下ID标识。 这个例子说明我们存储一条新的记录时候，ContactID作为主键标识，系统自动分配，标识种子为1，所以每次自动加一。 //ContactID是主键ID，插入一条数据，系统自动分配ID Contact con = new Contact() { CompanyName = "New Era", Phone = "(123)-456-7890" }; db.Contacts.InsertOnSubmit(con); db.SubmitChanges(); LINQ体验(18)——LINQ to SQL语句之视图和继承支持 视图 我们使用视图和使用数据表类似，只需将视图从“服务器资源管理器/数据库资源管理器”拖动到O/R 设计器上，自动可以创建基于这些视图的实体类。我们可以同操作数据表一样来操作视图了。这里注意:O/R 设计器是一个简单的对象关系映射器，因为它仅支持 1:1 映射关系。换句话说，实体类与数据库表或视图之间只能具有 1:1 映射关系。不支持复杂映射(例如，将一个实体类映射到多个表)。但是，可以将一个实体类映射到一个联接多个相关表的视图。 下面使用NORTHWND数据库中自带的Invoices、Quarterly Orders两个视图为例，写出两个范例。 查询:匿名类型形式 我们使用下面代码来查询出ShipCity 在London的发票。 var q = from i in db.Invoices where i.ShipCity == "London" select new { i.OrderID, i.ProductName, i.Quantity, i.CustomerName }; 这里，生成的SQL语句同使用数据表类似: SELECT [t0].[OrderID], [t0].[ProductName], [t0].[Quantity], [t0].[CustomerName] FROM [dbo].[Invoices] AS [t0] WHERE [t0].[ShipCity] = @p0 -- @p0: Input NVarChar (Size = 6; Prec = 0; Scale = 0) [London] 查询:标识映射形式 下例查询出每季的订单。 var q = from qo in db.Quarterly_Orders select qo; 生成SQL语句为: SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[City], [t0].[Country] FROM [dbo].[Quarterly Orders] AS [t0] 继承支持 LINQ to SQL 支持单表映射，其整个继承层次结构存储在单个数据库表中。该表包含整个层次结构的所有可能数据列的平展联合。(联合是将两个表组合成一个表的结果，组合后的表包含任一原始表中存在的行。)每行中 null。 不适用于该行所表示的实例类型的列为 单表映射策略是最简单的继承表示形式，为许多不同类别的查询提供了良好的性能特征，如果我们要在 LINQ to SQL 中实现这种映射，必须在继承层次结构的根类中指定属性 (Attribute) 和属性 (Attribute) 的属性 (Property)。我们还可以使用O/R设计器来映射继承层次结构，它自动生成了代码。 下面为了演示下面的几个例子，我们在O/R设计器内设计如下图所示的类及其继承关系。 我们学习的时候还是看看其生成的代码吧～ 具体设置映射继承层次结构有如下几步: 1. 根类添加TableAttribute属性。 2. 为层次结构中的每个类添加InheritanceMappingAttribute属性，同样 是添加到根类中。每个 InheritanceMappingAttribute属性，定义一个 Code属性和一个Type属性。Code属性的值显示在数据库表的 IsDiscriminator列中，用来指示该行数据所属的类或子类。Type属性值 指定键值所表示的类或子类。 3. 仅在其中一个InheritanceMappingAttribute属性上，添加一个 IsDefault属性用来在数据库表中的鉴别器值在继承映射中不与任何 Code值匹配时指定回退映射。 4. 为ColumnAttribute属性添加一个IsDiscriminator属性来表示这是保 存Code值的列。 下面是这张图生成的代码的框架(由于生成的代码太多，我删除了很多“枝叶”，仅仅保留了主要的框架用于指出其实质的东西): [Table(Name = "dbo.Contacts")] [InheritanceMapping(Code = "Unknown", Type = typeof(Contact), IsDefault = true)] [InheritanceMapping(Code = "Employee", Type = typeof(EmployeeContact))] [InheritanceMapping(Code = "Supplier", Type = typeof(SupplierContact))] [InheritanceMapping(Code = "Customer", Type = typeof(CustomerContact))] [InheritanceMapping(Code = "Shipper", Type = typeof(ShipperContact))] public partial class Contact : INotifyPropertyChanging, INotifyPropertyChanged { [Column(Storage = "_ContactID",IsPrimaryKey = true, IsDbGenerated = true)] public int ContactID{ } [Column(Storage = "_ContactType",IsDiscriminator = true)] public string ContactType{ } } public abstract partial class FullContact : Contact{ } public partial class EmployeeContact : FullContact{ } public partial class SupplierContact : FullContact{ } public partial class CustomerContact : FullContact{ } public partial class ShipperContact : Contact{ } 1.一般形式 日常我们经常写的形式，对单表查询。 var cons = from c in db.Contacts select c; foreach (var con in cons) { Console.WriteLine("Company name: {0}", con.CompanyName); Console.WriteLine("Phone: {0}", con.Phone); Console.WriteLine("This is a {0}", con.GetType()); } 2.OfType形式 这里我仅仅让其返回顾客的联系方式。 var cons = from c in db.Contacts.OfType() select c; 初步学习，我们还是看看生成的SQL语句，这样容易理解。在SQL语句中 查询了ContactType为Customer的联系方式。 SELECT [t0].[ContactType], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Fax],[t0].[ContactID], [t0].[CompanyName], [t0].[Phone] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[ContactType] = @p0) AND ([t0].[ContactType] IS NOT NULL) -- @p0: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Customer] 3.IS形式 这个例子查找一下发货人的联系方式。 var cons = from c in db.Contacts where c is ShipperContact select c; 生成的SQL语句如下:查询了ContactType为Shipper的联系方式。大致 一看好像很上面的一样，其实这里查询出来的列多了很多。实际上是 Contacts表的全部字段。 SELECT [t0].[ContactType], [t0].[ContactID], [t0].[CompanyName], [t0].[Phone],[t0].[HomePage], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Fax],[t0].[PhotoPath], [t0].[Photo], [t0].[Extension] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[ContactType] = @p0) AND ([t0].[ContactType] IS NOT NULL) -- @p0: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Shipper] 4.AS形式 这个例子就通吃了，全部查找了一番。 var cons = from c in db.Contacts select c as FullContact; 生成SQL语句如下:查询整个Contacts表。 SELECT [t0].[ContactType], [t0].[HomePage], [t0].[ContactName], [t0].[ContactTitle],[t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Fax], [t0].[ContactID], [t0].[CompanyName], [t0].[Phone], [t0].[PhotoPath],[t0].[Photo], [t0].[Extension] FROM [dbo].[Contacts] AS [t0] 5.Cast形式 使用Case形式查找出在伦敦的顾客的联系方式。 var cons = from c in db.Contacts where c.ContactType == "Customer" && ((CustomerContact)c).City == "London" select c; 生成SQL语句如下，自己可以看懂了。 SELECT [t0].[ContactType], [t0].[ContactID], [t0].[CompanyName], [t0].[Phone], [t0].[HomePage],[t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Fax], [t0].[PhotoPath], [t0].[Photo], [t0].[Extension]FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[ContactType] = @p0) AND ([t0].[City] = @p1) -- @p0: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Customer] -- @p1: Input NVarChar (Size = 6; Prec = 0; Scale = 0) [London] 6.UseAsDefault形式 当插入一条记录时，使用默认的映射关系了，但是在查询时，使用继承的 关系了。具体看看生成的SQL语句就直截了当了。 //插入一条数据默认使用正常的映射关系 Contact contact = new Contact() { ContactType = null, CompanyName = "Unknown Company", Phone = "333-444-5555" }; db.Contacts.InsertOnSubmit(contact); db.SubmitChanges(); //查询一条数据默认使用继承映射关系 var con = (from c in db.Contacts where c.CompanyName == "Unknown Company" && c.Phone == "333-444-5555" select c).First(); 生成SQL语句如下: INSERT INTO [dbo].[Contacts]([ContactType], [CompanyName], [Phone]) VALUES (@p0, @p1, @p2) SELECT TOP (1) [t0].[ContactType], [t0].[ContactID], [t0].[CompanyName], [t0].[Phone],[t0].[HomePage], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City],[t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Fax], [t0].[PhotoPath],[t0].[Photo], [t0].[Extension] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[CompanyName] = @p0) AND ([t0].[Phone] = @p1) -- @p0: Input NVarChar (Size = 15; Prec = 0; Scale = 0) [Unknown Company] -- @p1: Input NVarChar (Size = 12; Prec = 0; Scale = 0) [333-444-5555] 7.插入新的记录 这个例子说明如何插入发货人的联系方式的一条记录。 //1.在插入之前查询一下，没有数据 var ShipperContacts = from sc in db.Contacts.OfType() where sc.CompanyName == "Northwind Shipper" select sc; //2.插入数据 ShipperContact nsc = new ShipperContact() { CompanyName = "Northwind Shipper", Phone = "(123)-456-7890" }; db.Contacts.InsertOnSubmit(nsc); db.SubmitChanges(); //3.查询数据，有一条记录 ShipperContacts = from sc in db.Contacts.OfType() where sc.CompanyName == "Northwind Shipper" select sc; //4.删除记录 db.Contacts.DeleteOnSubmit(nsc); db.SubmitChanges(); 生成SQL语句如下: SELECT COUNT(*) AS [value] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[CompanyName] = @p0) AND ([t0].[ContactType] = @p1) AND ([t0].[ContactType] IS NOT NULL) -- @p0: Input NVarChar [Northwind Shipper] -- @p1: Input NVarChar [Shipper] INSERT INTO [dbo].[Contacts]([ContactType], [CompanyName], [Phone]) VALUES (@p0, @p1, @p2) -- @p0: Input NVarChar [Shipper] -- @p1: Input NVarChar [Northwind Shipper] -- @p2: Input NVarChar [(123)-456-7890] SELECT COUNT(*) AS [value] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[CompanyName] = @p0) AND ([t0].[ContactType] = @p1) AND ([t0].[ContactType] IS NOT NULL) -- @p0: Input NVarChar [Northwind Shipper] -- @p1: Input NVarChar [Shipper] DELETE FROM [dbo].[Contacts] WHERE ([ContactID] = @p0) AND ([ContactType] = @p1) AND ([CompanyName] = @p2) AND ([Phone] = @p3) -- @p0: Input Int [159] -- @p1: Input NVarChar [Shipper] -- @p2: Input NVarChar [Northwind Shipper] -- @p3: Input NVarChar [(123)-456-7890] -- @p4: Input NVarChar [Unknown] -- @p5: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Supplier] -- @p6: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Shipper] -- @p7: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Employee] -- @p8: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Customer]
    本文档为【目前本人收集的最全的LINQ入门资料~~大家一起LINQ吧】，请使用软件OFFICE或WPS软件打开。作品中的文字与图均可以修改和编辑， 图片更改请在作品中右键图片并更换，文字修改请直接点击文字进行修改，也可以新增和删除文档中的内容。
    该文档来自用户分享，如有侵权行为请发邮件ishare@vip.sina.com联系网站客服，我们会及时删除。
    [版权声明] 本站所有资料为用户分享产生，若发现您的权利被侵害，请联系客服邮件isharekefu@iask.cn，我们尽快处理。
    本作品所展示的图片、画像、字体、音乐的版权可能需版权方额外授权，请谨慎使用。
    网站提供的党政主题相关内容(国旗、国徽、党徽..)目的在于配合国家政策宣传，仅限个人学习分享使用，禁止用于任何广告和商用目的。
    下载需要： 免费 已有0 人下载
    立即下载

    你可能还喜欢

    最新资料
    资料动态
    专题动态
    is_079973
    暂无简介~
    格式：doc
    大小：1MB
    软件：Word
    页数：0
    分类：
    上传时间：2018-07-22
    浏览量：10
    相关资料
    热点搜索
    个人辞职申请报告 多普勒超声心动图对88例正常儿童右心室舒张功能参数测定 知识库建设方案【精品文档】 0-6岁儿童健康教育知识讲座 女性时装网络店铺文献综述 PV节点_PQ节点_平衡节点介绍 中华人民共和国传染病报告卡(2015年版)增加埃博拉AFP 修毛刺作业指导书 一年级小学生评语百度文库 电磁场的远场和近场划分 2009陕西定额说明绿化与园林 苏教版四年级数学下册教案全册 将军冢 铝电解培训教材1(初稿) 个人辞职申请报告 多普勒超声心动图对88例正常儿童右心室舒张功能参数测定 知识库建设方案【精品文档】 0-6岁儿童健康教育知识讲座 女性时装网络店铺文献综述 PV节点_PQ节点_平衡节点介绍 中华人民共和国传染病报告卡(2015年版)增加埃博拉AFP 修毛刺作业指导书 一年级小学生评语百度文库 电磁场的远场和近场划分 2009陕西定额说明绿化与园林 苏教版四年级数学下册教案全册 将军冢 铝电解培训教材1(初稿)
    资料大全 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0-9
    专题大全 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0-9

    网站声明 | 侵权处理 | 投诉反馈 | 帮助中心 | 网站地图 | 爱问办公

    京ICP证000007-6 爱问文库-Copyright © 2024 版权所有

    浙公网安备 33021202002483

    客服热线：0755-26904047

    工作日：9:00-18:00

    在线客服

    • 关注爱问文库服务号