文档章节

Linq To Sql语法及实例大全

o
 osc_fmg49rzg
发布于 2019/03/19 14:49
字数 30346
阅读 0
收藏 0

精选30+云产品,助力企业轻松上云!>>>

 

关于LINQ to SQL我想还有许多人还不太了解吧,下面是一些关于它的语法及操作了,提供给大家分享!

 

Linq To Sql语句(1)之Where

 

where操作

适用场景:实现过滤,查询等功能。

 

说明:与SQL命令中的Where作用相似,都是起到范围限定也就是过滤作用的,而判断条件就是它后面所接的子句。

 

Where操作包括3种形式,分别为简单形式关系条件形式First()形式。下面分别用实例举例下:

例如:使用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;
1.简单形式:
 1 筛选库存量在订货点水平之下但未断货的产品:
 2 
 3  
 4 
 5 var q =
 6 
 7   from p in db.Products
 8 
 9   where p.UnitsInStock <= p.ReorderLevel && !p.Discontinued
10 
11   select p;
12 
13  
14 
15 筛选出UnitPrice 大于10 或已停产的产品:
16 
17  
18 
19 var q =
20 
21   from p in db.Products
22 
23   where p.UnitPrice > 10m || p.Discontinued
24 
25   select p;
26 
27  
28 
29 下面这个例子是调用两次where以筛选出UnitPrice大于10且已停产的产品。
30 
31  
32 
33 var q =
34 
35   db.Products.Where(p=>p.UnitPrice > 10m).Where(p=>p.Discontinued);
2.关系条件形式:
返回集合中的一个元素,其实质就是在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);
3.First()形式:

LINQ to SQL语句(2)之Select/Distinct

[1] Select介绍1

 

[2] Select介绍2 

 

[3] Select介绍3和 Distinct介绍

 Select/Distinct操作符

 适用场景:o(∩_∩) o…查询呗。

 

说明:和SQL命令中的select作用相似但位置不同,查询表达式中的select及所接子句是放在表达式最后并把子句中的变量也就是结果返回回来;延迟。

 

Select/Distinct操作包括9种形式,分别为简单用 法、匿名类型形式、条件形式、指定类型形式、筛选形式、整形类型形式、嵌套类型形式、本地方法调用形式、Distinct形式。

 1 这个示例返回仅含客户联系人姓名的序列。
 2 
 3  
 4 
 5 var q =
 6 
 7   from c in db.Customers
 8 
 9   select c.ContactName;
10 
11  
12 
13 注意:这个语句只是一个声明或者一个描述,并没有真正把数据取出来,只有当你需要该数据的时候,它才会执行这个语句,这就是延迟加载(deferred loading)。如果,在声明的时候就返回的结果集是对象的集合。你可以使用ToList() 或ToArray()方法把查询结果先进行保存,然后再对这个集合进行查询。当然延迟加载(deferred loading)可以像拼接SQL语句那样拼接查询语法,再执行它。
1.简单用法:
 1 说明:匿名类型是C#3.0中新特性。其实质是编译器根据我们自定义自动产生一个匿名的类来帮助我们实现临时变量的储存。匿名类型还依赖于另外一个特性:支持根据property来创建对象。比如,var d = new { Name = "s" };编译器自动产生一个有property叫做Name的匿名类,然后按这 个类型分配内存,并初始化对象。但是var d = new {"s"};是编译不 通过的。因为,编译器不知道匿名类中的property的名字。例如stringc = "d";var d = new { c}; 则是可以通过编译的。编译器会创建一个叫 做匿名类带有叫c的property。
 2 
 3  
 4 
 5 例如下例:new {c,ContactName,c.Phone};ContactName和Phone都是在映射文件中定义与表中字 段相对应的property。编译器读取数据并创建对象时,会创建一个匿名类,这个 类有两个属性,为ContactName和Phone,然后根据数据初始化对象。另外编译器 还可以重命名property的名字。
 6 
 7  
 8 
 9 var q =
10 
11   from c in db.Customers
12 
13   select new {c.ContactName, c.Phone};
14 
15  
16 
17 上面语句描述:使用 SELECT 和匿名类型返回仅含客户联系人姓名和电话号码的序列
18 
19  
20 
21 var q =
22 
23   from e in db.Employees
24 
25   select new
26 
27   {
28 
29     Name = e.FirstName + " " + e.LastName,
30 
31     Phone = e.HomePhone
32 
33   };
34 
35  
36 
37 上面语句描述:使用SELECT和匿名类型返回仅含雇员姓名和电话号码的序列,并将 FirstName和LastName字段合并为一个字段“Name”,此外在所得的序列中将HomePhone字段重命名为Phone。
38 
39  
40 
41 var q =
42 
43   from p in db.Products
44 
45   select new
46 
47   {
48 
49      p.ProductID,
50 
51     HalfPrice = p.UnitPrice / 2
52 
53   };
54 
55  
56 
57 上面语句描述:使用SELECT和匿名类型返回所有产品的ID以及 HalfPrice(设置为产品单价除以2所得的值)的序列。
2.匿名类型形式:
 1 说明:生成SQL语句为:case when condition then else 2 
 3  
 4 
 5 var q =
 6 
 7   from p in db.Products
 8 
 9   select new
10 
11   {
12 
13     p.ProductName,
14 
15     Availability =
16 
17      p.UnitsInStock - p.UnitsOnOrder < 0 ?
18 
19     "Out Of Stock" : "In Stock"
20 
21   };
22 
23  
24 
25 上面语句描述:使用SELECT和条件语句返回产品名称和产品供货状态的序列。
3.条件形式:
 1 说明:该形式返回你自定义类型的对象集。
 2 
 3  
 4 
 5 var q =
 6 
 7   from e in db.Employees
 8 
 9   select new Name
10 
11    {
12 
13     FirstName = e.FirstName,
14 
15     LastName = e.LastName
16 
17   };
18 
19  
20 
21 上面语句描述:使用SELECT和已知类型返回雇员姓名的序列。
4.指定类型形式:
 1 说明:结合where使用,起到过滤作用。
 2 
 3  
 4 
 5 var q =
 6 
 7   from c in db.Customers
 8 
 9    where c.City == "London"
10 
11   select c.ContactName;
12 
13  
14 
15 上面语句描述:使用SELECT和WHERE返回仅含伦敦客户联系人姓名的序列。
5.筛选形式:
 1 说明:其select操作使用了匿名对象,而这个匿名对象中,其属性也是个匿名对象。
 2 
 3  
 4 
 5 var q =
 6 
 7   from c in db.Customers
 8 
 9   select new {
10 
11     c.CustomerID,
12 
13     CompanyInfo = new {c.CompanyName, c.City, c.Country},
14 
15     ContactInfo = new {c.ContactName, c.ContactTitle}
16 
17   };
18 
19  
20 
21 语句描述:使用 SELECT 和匿名类型返回有关客户的数据的整形子集。查询顾客的ID和公司信息(公司名称,城市,国家)以及联系信息(联系人和职位)。
6.shaped形式(整形类型):
 1 说明:返回的对象集中的每个对象DiscountedProducts属性中,又包含一个集合。也就是每个对象也是一个集合类。
 2 
 3  
 4 
 5 var q =
 6 
 7   from o in db.Orders
 8 
 9   select new {
10 
11      o.OrderID,
12 
13     DiscountedProducts =
14 
15       from od in o.OrderDetails
16 
17       where od.Discount > 0.0
18 
19       select od,
20 
21     FreeShippingDiscount = o.Freight
22 
23   };
24 
25  
26 
27 语句描述:使用嵌套查询返回所有订单及其OrderID 的序列、打折订单中项目的子序列以及免送货所省下的金额。
7.嵌套类型形式:
 1 这个例子在查询中调用本地方法 PhoneNumberConverter将电话号码转换为国际格式。
 2 
 3  
 4 
 5 var q = from c in db.Customers
 6 
 7      where c.Country == "UK" || c.Country == "USA"
 8 
 9      select new
10 
11      {
12 
13        c.CustomerID,
14 
15        c.CompanyName,
16 
17        Phone = c.Phone,
18 
19        InternationalPhone =
20 
21        PhoneNumberConverter(c.Country, c.Phone)
22 
23      };
24 
25  
26 
27 PhoneNumberConverter方法如下:
28 
29  
30 
31 public string PhoneNumberConverter(stringCountry, string Phone)
32 
33 {
34 
35   Phone = Phone.Replace(" ", "").Replace(")", ")-");
36 
37   switch (Country)
38 
39    {
40 
41     case "USA":
42 
43       return "1- " + Phone;
44 
45     case "UK":
46 
47        return "44-" + Phone;
48 
49     default:
50 
51       return Phone;
52 
53   }
54 
55 }
56 
57  
58 
59 下面也是使用了这个方法将电话号码转换为国际格式并创建XDocument
60 
61  
62 
63 XDocument doc = new XDocument(
64 
65   new XElement("Customers", from c in db.Customers
66 
67        where c.Country == "UK" || c.Country == "USA"
68 
69        select (new XElement ("Customer",
70 
71            new XAttribute ("CustomerID", c.CustomerID),
72 
73            new XAttribute("CompanyName", c.CompanyName),
74 
75            new XAttribute("InterationalPhone",
76 
77             PhoneNumberConverter(c.Country, c.Phone))
78 
79            ))));
8.本地方法调用形式(LocalMethodCall):
 1 说明:筛选字段中不相同的值。用于查询不重复的结果集。生成SQL语句为:SELECT DISTINCT [City] FROM [Customers]
 2 
 3  
 4 
 5 var q = (
 6 
 7   from c in db.Customers
 8 
 9   select c.City )
10 
11   .Distinct();
12 
13  
14 
15 语句描述:查询顾客覆盖的国家。
9.Distinct形式:

LINQ to SQL语句(3)之Count/Sum/Min/Max/Avg

[1] Count/Sum讲解

 

[2] Min讲解

 

[3] Max讲解

 

[4] Average和Aggregate讲解

 

Count/Sum/Min/Max/Avg操作符

 

适用场景:统计数据吧,比如统计一些数据的个数,求和,最小值,最大值,平均数。

 

 

  1 Count
  2 
  3  
  4 
  5 说明:返回集合中的元素个数,返回INT类型;不延迟。生成 SQL语句为:SELECT COUNT(*) FROM
  6 
  7  
  8 
  9 1.简单形式:
 10 
 11  
 12 
 13 得到数据库中客户的数量:
 14 
 15  
 16 
 17 var q = db.Customers.Count();
 18 
 19  
 20 
 21 2.带条件形式:
 22 
 23  
 24 
 25 得到数据库中未断货产品的数量:
 26 
 27  
 28 
 29 var q = db.Products.Count(p =>!p.Discontinued);
 30 
 31  
 32 
 33 LongCount
 34 
 35  
 36 
 37 说明:返回集合中的元素个数,返回LONG类型;不延迟。对于元素个数较多的集合可视情况可以选用LongCount来统计元素个数,它返回long类型,比较精确。生成 SQL语句为:SELECT COUNT_BIG(*) FROM
 38 
 39  
 40 
 41 var q = db.Customers.LongCount();
 42 
 43  
 44 
 45 Sum
 46 
 47  
 48 
 49 说明:返回集合中数值类型元素之和,集合应为INT类型集合;不延迟。生成SQL语句为:SELECT SUM(…) FROM
 50 
 51  
 52 
 53 1.简单形式:
 54 
 55  
 56 
 57 得到所有订单的总运费:
 58 
 59  
 60 
 61 var q = db.Orders.Select(o =>o.Freight).Sum();
 62 
 63  
 64 
 65 2.映射形式:
 66 
 67  
 68 
 69 得到所有产品的订货总数:
 70 
 71  
 72 
 73 var q = db.Products.Sum(p =>p.UnitsOnOrder);
 74 
 75 Min
 76 
 77 说明:返回集合中元素的最小值;不延迟。生成SQL语句为:SELECT MIN(…) FROM
 78 
 79 1.简单形式:
 80 
 81 查找任意产品的最低单价:
 82 
 83 var q = db.Products.Select(p => p.UnitPrice).Min();
 84 
 85  
 86 
 87 2.映射形式:
 88 
 89  
 90 
 91 查找任意订单的最低运费:
 92 
 93  
 94 
 95 var q = db.Orders.Min(o => o.Freight);
 96 
 97  
 98 
 99  
100 
101 3.元素:
102 
103  
104 
105 查找每个类别中单价最低的产品:
106 
107  
108 
109 var categories =
110 
111   from p in db.Products
112 
113   group p by p.CategoryID into g
114 
115   select new {
116 
117     CategoryID = g.Key,
118 
119      CheapestProducts =
120 
121       from p2 in g
122 
123        where p2.UnitPrice == g.Min(p3 => p3.UnitPrice)
124 
125        select p2
126 
127   };
128 
129 Max
130 
131 说明:返回集合中元素的最大值;不延迟。生成SQL语句为:SELECT MAX(…) FROM
132 
133 1.简单形式:
134 
135 查找任意雇员的最近雇用日期:
136 
137 var q = db.Employees.Select(e => e.HireDate).Max();
138 
139  
140 
141 2.映射形式:
142 
143  
144 
145 查找任意产品的最大库存量:
146 
147  
148 
149 var q = db.Products.Max(p =>p.UnitsInStock);
150 
151  
152 
153 3.元素:
154 
155  
156 
157 查找每个类别中单价最高的产品:
158 
159  
160 
161 var categories =
162 
163   from p in db.Products
164 
165    group p by p.CategoryID into g
166 
167   select new {
168 
169      g.Key,
170 
171     MostExpensiveProducts =
172 
173       from p2 in g
174 
175       where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
176 
177       select p2
178 
179   };
180 
181 Average
182 
183 说明:返回集合中的数值类型元素的平均值。集合应为数字类型集合,其返回值类型为double;不延迟。生成SQL语句为:SELECT AVG(…) FROM
184 
185 1.简单形式:
186 
187 得到所有订单的平均运费:
188 
189 var q = db.Orders.Select(o =>o.Freight).Average();
190 
191  
192 
193 2.映射形式:
194 
195  
196 
197 得到所有产品的平均单价:
198 
199  
200 
201 var q = db.Products.Average(p => p.UnitPrice);
202 
203  
204 
205 3.元素:
206 
207  
208 
209 查找每个类别中单价高于该类别平均单价的产品:
210 
211  
212 
213 var categories =
214 
215   from p in db.Products
216 
217   group p by p.CategoryID into g
218 
219   select new {
220 
221     g.Key,
222 
223     ExpensiveProducts =
224 
225       from p2 in g
226 
227       where p2.UnitPrice > g.Average (p3 => p3.UnitPrice)
228 
229       select p2
230 
231   };
232 
233  
234 
235 Aggregate
236 
237  
238 
239 说明:根据输入的表达式获取聚合值;不延迟。即是说:用一个种子值与当前元素通过指定的函数来进行对比来遍历集合中的元素,符合条件的元素保留下来。如果没有指定种子值的话,种子值默认为集合的第一个元素。
Count/Sum/Min/Max/Avg

 

LINQ to SQL语句(4)之Join

Join操作符

适用场景:在我们表关系中有一对一关系,一对多关系,多对多关系等。对各个表之间的关系,就用这些实现对多个表的操作。

 

说明:在Join操作中,分别为Join(Join查询), SelectMany(Select一对多选择) 和GroupJoin(分组Join查询)。

 

该扩展方法对两个序列中键匹配的元素进行inner join操作

 

SelectMany

 

说明:我们在写查询语句时,如果被翻译成SelectMany需要满足2个条件。1:查询语句中没有join和into,2:必须出现EntitySet。在我们表关系中有一对一关系,一对多关系,多对多关系等,下面分别介绍一下。

 

  1 1.一对多关系(1 to Many):
  2 
  3  
  4 
  5 var q =
  6 
  7   from c in db.Customers
  8 
  9   from o in c.Orders
 10 
 11   where c.City == "London"
 12 
 13   select o;
 14 
 15  
 16 
 17 语句描述:Customers与Orders是一对多关系。即Orders在Customers类中以 EntitySet形式出现。所以第二个from是从c.Orders而不是db.Orders里进行筛选。这个例子在From子句中使用外键导航选择伦敦客户的所有订单。
 18 
 19  
 20 
 21 var q =
 22 
 23   from p in db.Products
 24 
 25   where p.Supplier.Country == "USA" &&p.UnitsInStock == 0
 26 
 27   select p;
 28 
 29  
 30 
 31 语句描述:这一句使用了 p.Supplier.Country条件,间接关联了Supplier表。这个例子在Where子句中使用外键导航筛选其供应商在美国且缺货的产品。生成SQL语句为:
 32 
 33  
 34 
 35 SELECT [t0].[ProductID],[t0].[ProductName], [t0]. [SupplierID],
 36 
 37 [t0].[CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice],
 38 
 39 [t0].[UnitsInStock],[t0].[UnitsOnOrder],[t0]. [ReorderLevel],
 40 
 41 [t0].[Discontinued] FROM [dbo].[Products]AS [t0]
 42 
 43 LEFT OUTER JOIN [dbo].[Suppliers] AS [t1]ON
 44 
 45 [t1]. [SupplierID] = [t0].[SupplierID]
 46 
 47 WHERE ([t1].[Country] = @p0) AND([t0].[UnitsInStock] = @p1)
 48 
 49 -- @p0: Input NVarChar (Size = 3; Prec = 0;Scale = 0) [USA]
 50 
 51 -- @p1: Input Int (Size = 0; Prec = 0;Scale = 0) [0]
 52 
 53  
 54 
 55 2.多对多关系(Many to Many):
 56 
 57  
 58 
 59 var q =
 60 
 61   from e in db.Employees
 62 
 63   from et in e.EmployeeTerritories
 64 
 65   where e.City == "Seattle"
 66 
 67   select new
 68 
 69   {
 70 
 71     e.FirstName,
 72 
 73      e.LastName,
 74 
 75     et.Territory.TerritoryDescription
 76 
 77   };
 78 
 79  
 80 
 81 说明:多对多关系一般会涉及三个表(如果有一个表是自关联的,那有可能只有2个表)。这一句语句涉及Employees, EmployeeTerritories, Territories三个表。它们的关系是1:M:1。Employees 和Territories没有很明确的关系。
 82 
 83  
 84 
 85 语句描述:这个例子在From子句中使用外键导航筛选在西雅图的雇员,同时列出其所在地区。这条生成SQL语句为:
 86 
 87  
 88 
 89 SELECT [t0].[FirstName], [t0].[LastName],[t2]. [TerritoryDescription]
 90 
 91 FROM [dbo].[Employees] AS [t0] CROSS JOIN[dbo].[EmployeeTerritories]
 92 
 93 AS [t1] INNER JOIN [dbo]. [Territories] AS[t2] ON
 94 
 95 [t2].[TerritoryID] = [t1].[TerritoryID]
 96 
 97 WHERE ([t0].[City] = @p0) AND([t1].[EmployeeID] = [t0]. [EmployeeID])
 98 
 99 -- @p0: Input NVarChar (Size = 7; Prec = 0;Scale = 0) [Seattle]
100 
101  
102 
103  
104 
105 3.自联接关系:
106 
107  
108 
109 var q =
110 
111   from e1 in db.Employees
112 
113   from e2 in e1.Employees
114 
115   where e1.City == e2.City
116 
117   select new {
118 
119     FirstName1 = e1.FirstName, LastName1 = e1.LastName,
120 
121     FirstName2 = e2.FirstName, LastName2 = e2.LastName,
122 
123     e1.City
124 
125   };
126 
127  
128 
129 语句描述:这个例子在select 子句中使用外键导航筛选成对的雇员,每对中一个雇员隶属于另一个雇员,且两个雇员都来自相同城市。生成SQL语句为:
130 
131  
132 
133 SELECT [t0].[FirstName] AS [FirstName1],[t0].[LastName] AS
134 
135 [LastName1],[t1].[FirstName] AS[FirstName2], [t1].[LastName] AS
136 
137 [LastName2],[t0].[City] FROM[dbo].[Employees] AS [t0],
138 
139 [dbo].[Employees] AS [t1] WHERE([t0].[City] = [t1]. [City]) AND
140 
141 ([t1].[ReportsTo] = [t0].[EmployeeID])
142 
143 GroupJoin
144 
145  
146 
147 像上面所说的,没有join和into,被翻译成 SelectMany,同时有join和into时,那么就被翻译为GroupJoin。在这里into的概念是对其结果进行重新命名。
148 
149  
150 
151 1.双向联接(Two way join):
152 
153  
154 
155 此示例显式联接两个表并从这两个表投影出结果:
156 
157  
158 
159 var q =
160 
161    from c in db.Customers
162 
163   join o in db.Orders on c.CustomerID
164 
165   equals o.CustomerID into orders
166 
167   select new
168 
169    {
170 
171     c.ContactName,
172 
173     OrderCount = orders.Count ()
174 
175   };
176 
177  
178 
179 说明:在一对多关系中,左边是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返回值作为字段值。如图所示:
180 
181  
182 
183  
184 
185  
186 
187 生成SQL语句为:
188 
189  
190 
191 SELECT [t0].[ContactName], (
192 
193   SELECT COUNT(*)
194 
195   FROM [dbo].[Orders] AS [t1]
196 
197    WHERE [t0].[CustomerID] = [t1].[CustomerID]
198 
199 ) AS [OrderCount]
200 
201 FROM [dbo].[Customers] AS [t0]
202 
203  
204 
205 2.三向联接(There way join):
206 
207  
208 
209 此示例显式联接三个表并分别从每个表投影出结果:
210 
211  
212 
213 var q =
214 
215   from c in db.Customers
216 
217   join o in db.Orders on c.CustomerID
218 
219   equals o.CustomerID into ords
220 
221   join e in db.Employees on c.City
222 
223   equals e.City into emps
224 
225   select new
226 
227   {
228 
229     c.ContactName,
230 
231     ords = ords.Count(),
232 
233     emps = emps.Count()
234 
235   };
236 
237  
238 
239 生成SQL语句为:
240 
241  
242 
243 SELECT [t0]. [ContactName], (
244 
245   SELECT COUNT(*)
246 
247   FROM [dbo].[Orders] AS [t1]
248 
249   WHERE [t0].[CustomerID] = [t1].[CustomerID]
250 
251 ) AS [ords], (
252 
253 SELECT COUNT(*)
254 
255   FROM [dbo].[Employees] AS [t2]
256 
257   WHERE [t0].[City] = [t2].[City]
258 
259 ) AS [emps]
260 
261 FROM [dbo].[Customers] AS [t0]
262 
263  
264 
265 3.左外部联接(Left Outer Join):
266 
267  
268 
269 此示例说明如何通过使用此示例说明如何通过使用 DefaultIfEmpty() 获取左外部联接。在雇员没有订单时,DefaultIfEmpty()方法返回null:
270 
271  
272 
273 var q =
274 
275   from e in db.Employees
276 
277    join o in db.Orders on e equals o.Employee into ords
278 
279   from o in ords.DefaultIfEmpty()
280 
281   select new
282 
283   {
284 
285      e.FirstName,
286 
287     e.LastName,
288 
289     Order = o
290 
291    };
292 
293  
294 
295 说明:以Employees左表,Orders右表,Orders 表中为空时,用null值填充。Join的结果重命名ords,使用DefaultIfEmpty()函数对其再次查询。其最后的结果中有个Order,因为from o in ords.DefaultIfEmpty() 是对 ords组再一次遍历,所以,最后结果中的Order并不是一个集合。但是,如果没有from o in ords.DefaultIfEmpty() 这句,最后的select语句写成selectnew { e.FirstName, e.LastName, Order = ords }的话,那么Order就是一个集合。
296 
297  
298 
299 4.投影的Let赋值(Projectedlet assignment):
300 
301  
302 
303 说明:let语句是重命名。let位于第一个from和select语句之间。
304 
305  
306 
307 这个例子从联接投影出最终“Let”表达式:
308 
309  
310 
311 var q =
312 
313   from c in db.Customers
314 
315   join o in db.Orders on c.CustomerID
316 
317    equals o.CustomerID into ords
318 
319   let z = c.City + c.Country
320 
321   from o in ords
322 
323   select new
324 
325   {
326 
327      c.ContactName,
328 
329     o.OrderID,
330 
331     z
332 
333   };
334 
335  
336 
337 5.组合键(Composite Key):
338 
339  
340 
341 这个例子显示带有组合键的联接:
342 
343  
344 
345 var q =
346 
347   from o in db.Orders
348 
349   from p in db.Products
350 
351   join d in db.OrderDetails
352 
353     on new
354 
355     {
356 
357       o.OrderID,
358 
359        p.ProductID
360 
361     } equals
362 
363       new
364 
365       {
366 
367         d.OrderID,
368 
369          d.ProductID
370 
371       }
372 
373     into details
374 
375   from d in details
376 
377   select new
378 
379   {
380 
381     o.OrderID,
382 
383     p.ProductID,
384 
385     d.UnitPrice
386 
387   };
388 
389  
390 
391 说明:使用三个表,并且用匿名类来说明:使用三个表,并且用匿名类来表示它们之间的关系。它们之间的关系不能用一个键描述清楚,所以用匿名类,来表示组合键。还有一种是两个表之间是用组合键表示关系的,不需要使用匿名类。
Json

 

LINQ to SQL语句(5)之Order By

Order By操作

 

适用场景:对查询出的语句进行排序,比如按时间排序等等。

 

 

 

说明:按指定表达式对集合排序;延迟,:按指定表达式对集合排序;延迟,默认是升序,加上descending表示降序,对应的扩展方法是 OrderBy和OrderByDescending

 

  1 1.简单形式
  2 
  3  
  4 
  5 这个例子使用 orderby 按雇用日期对雇员进行排序:
  6 
  7  
  8 
  9 var q =
 10 
 11   from e in db.Employees
 12 
 13   orderby e.HireDate
 14 
 15   select e;
 16 
 17  
 18 
 19 说明:默认为升序
 20 
 21  
 22 
 23 2.带条件形式
 24 
 25  
 26 
 27 注意:Where 和Order By的顺序并不重要。而在T-SQL中,Where和Order By有严格的位置限制。
 28 
 29  
 30 
 31 var q =
 32 
 33   from o in db.Orders
 34 
 35   where o.ShipCity == "London"
 36 
 37   orderby o.Freight
 38 
 39    select o;
 40 
 41  
 42 
 43 语句描述:使用where和orderby按运费进行排序。
 44 
 45  
 46 
 47 3.降序排序
 48 
 49  
 50 
 51 var q =
 52 
 53   from p in db.Products
 54 
 55   orderby p.UnitPrice descending
 56 
 57   select p;
 58 
 59  
 60 
 61  
 62 
 63 4.ThenBy
 64 
 65  
 66 
 67 语句描述:使用复合的 orderby 对客户进行排序,进行排序:
 68 
 69  
 70 
 71 var q =
 72 
 73   from c in db.Customers
 74 
 75   orderby c.City, c.ContactName
 76 
 77   select c;
 78 
 79  
 80 
 81 说明:按多个表达式进行排序,例如先按City排序,当City相同时,按ContactName排序。这一句用Lambda表达式像这样写:
 82 
 83  
 84 
 85 var q =
 86 
 87   .OrderBy(c => c.City)
 88 
 89   .ThenBy(c => c.ContactName).ToList();
 90 
 91  
 92 
 93 在T-SQL中没有 ThenBy语句,其依然翻译为OrderBy,所以也可以用下面语句来表达:
 94 
 95  
 96 
 97 var q =
 98 
 99   db.Customers
100 
101   .OrderBy(c => c.ContactName)
102 
103   .OrderBy(c => c.City).ToList ();
104 
105  
106 
107 所要注意的是,多个OrderBy操作时,级连方式是按逆序。对于降序的,用相应的降序操作符替换即可。
108 
109  
110 
111 var q =
112 
113    db.Customers
114 
115   .OrderByDescending(c => c.City)
116 
117   .ThenByDescending(c => c.ContactName).ToList();
118 
119  
120 
121 需要说明的是,OrderBy操作,不支持按type排序,也不支持匿名类。比如
122 
123  
124 
125 var q =
126 
127   db.Customers
128 
129   .OrderBy(c => new
130 
131   {
132 
133     c.City,
134 
135     c.ContactName
136 
137   }).ToList();
138 
139  
140 
141 会被抛出异常。错误是前面的操作有匿名类,再跟OrderBy时,比较的是类别。比如
142 
143  
144 
145 var q =
146 
147    db.Customers
148 
149   .Select(c => new
150 
151   {
152 
153      c.City,
154 
155     c.Address
156 
157   })
158 
159   .OrderBy(c => c).ToList();
160 
161  
162 
163 如果你想使用OrderBy(c => c),其前提条件是,前面步骤中,所产生的对象的类别必须为C#语言的基本类型。比如下句,这里 City为string类型。
164 
165  
166 
167 var q =
168 
169   db.Customers
170 
171    .Select(c => c.City)
172 
173   .OrderBy(c => c).ToList ();
174 
175  
176 
177  
178 
179 5.ThenByDescending
180 
181  
182 
183 这两个扩展方式都是用在 OrderBy/OrderByDescending之后的,第一个ThenBy/ThenByDescending扩展方法 作为第二位排序依据,第二个ThenBy/ThenByDescending则作为第三位排序依据 ,以此类推
184 
185  
186 
187 var q =
188 
189   from o in db.Orders
190 
191    where o.EmployeeID == 1
192 
193   orderby o.ShipCountry, o.Freight descending
194 
195   select o;
196 
197  
198 
199 语句描述:使用orderby先按发往国家再按运费从高到低的顺序对 EmployeeID 1 的订单进行排序。
200 
201  
202 
203 6. 带GroupBy形式
204 
205  
206 
207 var q =
208 
209   from p in db.Products
210 
211    group p by p.CategoryID into g
212 
213   orderby g.Key
214 
215   select new {
216 
217     g.Key,
218 
219     MostExpensiveProducts =
220 
221       from p2 in g
222 
223       where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
224 
225       select p2
226 
227   };
228 
229  
230 
231 语句描述:使用orderby、Max 和 Group By 得出每种类别中单价最高的产品,并按 CategoryID 对这组产品进行排序。
order by 排序

 

LINQ to SQL语句(6)之GroupBy/Having

Group By/Having操作符

 

适用场景:分组数据,为我们查找数据缩小范围。

 

 

 

说明:分配并返回对传入参数进行分组操作后的可枚举对象。分组;延迟

 

  1 1.简单形式:
  2 
  3  
  4 
  5 var q =
  6 
  7   from p in db.Products
  8 
  9   group p by p.CategoryID into g
 10 
 11   select g;
 12 
 13  
 14 
 15 语句描述:使用Group By按CategoryID划分产品。
 16 
 17  
 18 
 19 说明:from p in db.Products 表示从表中将产品对象取出来。group p by p.CategoryID into g表示对p按CategoryID字段归类。其结果命名为g,一旦重 新命名,p的作用域就结束了,所以,最后select时,只能select g。当然,也不必重新命名可以这样写:
 20 
 21  
 22 
 23 var q =
 24 
 25   from p in db.Products
 26 
 27   group p by p.CategoryID;
 28 
 29  
 30 
 31 我们用示意图表示:
 32 
 33  
 34 
 35  
 36 
 37 如果想遍历某类别中所有记录,这样:
 38 
 39  
 40 
 41 foreach (var gp in q)
 42 
 43 {
 44 
 45   if (gp.Key == 2)
 46 
 47   {
 48 
 49      foreach (var item in gp)
 50 
 51     {
 52 
 53       //do something
 54 
 55     }
 56 
 57   }
 58 
 59 }
 60 
 61  
 62 
 63 2.Select匿名类:
 64 
 65  
 66 
 67 var q =
 68 
 69   from p in db.Products
 70 
 71   group p by p.CategoryID into g
 72 
 73   select new { CategoryID = g.Key, g };
 74 
 75  
 76 
 77 说明:在这句LINQ语句中,有2个property:CategoryID和g。这个匿名类,其实质是对返回结果集重新进行了包装。把g的property封装成一个完整的分组。如下图所示:
 78 
 79  
 80 
 81  
 82 
 83 如果想遍历某匿名类中所有记录,要这么做:
 84 
 85  
 86 
 87 foreach (var gp in q)
 88 
 89 {
 90 
 91   if (gp.CategoryID == 2)
 92 
 93   {
 94 
 95     foreach (var item in gp.g)
 96 
 97     {
 98 
 99       //do something
100 
101     }
102 
103   }
104 
105 }
106 
107  
108 
109 3.最大值
110 
111  
112 
113 var q =
114 
115   from p in db.Products
116 
117   group p by p.CategoryID into g
118 
119   select new {
120 
121     g.Key,
122 
123     MaxPrice = g.Max(p => p.UnitPrice)
124 
125   };
126 
127  
128 
129 语句描述:使用Group By和Max查找每个CategoryID的最高单价。
130 
131  
132 
133 说明:先按CategoryID归类,判断各个分类产品中单价最大的 Products。取出CategoryID值,并把UnitPrice值赋给MaxPrice。
134 
135  
136 
137 4.最小值
138 
139  
140 
141 var q =
142 
143   from p in db.Products
144 
145   group p by p.CategoryID into g
146 
147   select new {
148 
149     g.Key,
150 
151     MinPrice = g.Min(p => p.UnitPrice)
152 
153   };
154 
155  
156 
157 语句描述:使用Group By和Min查找每个CategoryID的最低单价。
158 
159  
160 
161 说明:先按CategoryID归类,判断各个分类产品中单价最小的 Products。取出CategoryID值,并把UnitPrice值赋给MinPrice。
162 
163  
164 
165 5.平均值
166 
167  
168 
169 var q =
170 
171   from p in db.Products
172 
173   group p by p.CategoryID into g
174 
175   select new {
176 
177     g.Key,
178 
179     AveragePrice = g.Average(p => p.UnitPrice)
180 
181   };
182 
183  
184 
185 语句描述:使用Group By和Average得到每个CategoryID的平均单价。
186 
187  
188 
189 说明:先按CategoryID归类,取出CategoryID值和各个分类产品中单价的平均值。
190 
191  
192 
193 6.求和
194 
195  
196 
197 var q =
198 
199   from p in db.Products
200 
201   group p by p.CategoryID into g
202 
203   select new {
204 
205     g.Key,
206 
207     TotalPrice = g.Sum(p => p.UnitPrice)
208 
209   };
210 
211  
212 
213 语句描述:使用Group By和Sum得到每个CategoryID 的单价总计。
214 
215  
216 
217 说明:先按CategoryID归类,取出 CategoryID值和各个分类产品中单价的总和。
218 
219  
220 
221 7.计数
222 
223  
224 
225 var q =
226 
227   from p in db.Products
228 
229   group p by p.CategoryID into g
230 
231   select new {
232 
233     g.Key,
234 
235     NumProducts = g.Count()
236 
237   };
238 
239  
240 
241 语句描述:使用Group By和Count得到每个CategoryID中产品的数量。
242 
243  
244 
245 说明:先按CategoryID归类,取出 CategoryID值和各个分类产品的数量。
246 
247  
248 
249 8.带条件计数
250 
251  
252 
253 var q =
254 
255   from p in db.Products
256 
257   group p by p.CategoryID into g
258 
259   select new {
260 
261     g.Key,
262 
263     NumProducts = g.Count(p => p.Discontinued)
264 
265   };
266 
267  
268 
269 语句描述:使用Group By和Count得到每个CategoryID中断货产品的数量。
270 
271  
272 
273 说明:先按 CategoryID归类,取出CategoryID值和各个分类产品的断货数量。Count函数里,使用了Lambda表达式,Lambda表达式中的p,代表这个组里的一个元素或对象,即某一个产品。
274 
275  
276 
277 9.Where限制
278 
279  
280 
281 var q =
282 
283   from p in db.Products
284 
285   group p by p.CategoryID into g
286 
287   where g.Count() >= 10
288 
289   select new {
290 
291     g.Key,
292 
293     ProductCount = g.Count()
294 
295   };
296 
297  
298 
299 语句描述:根据产品的―ID分组,查询产品数量大于10的ID和产品数量。这个示例在Group By子句后使用Where子句查找所有至少有10种产品的类别。
300 
301  
302 
303 说明:在翻译成SQL 语句时,在最外层嵌套了Where条件。
304 
305  
306 
307 10.多列(Multiple Columns)
308 
309  
310 
311 var categories =
312 
313   from p in db.Products
314 
315    group p by new
316 
317   {
318 
319     p.CategoryID,
320 
321      p.SupplierID
322 
323   }
324 
325     into g
326 
327     select new
328 
329       {
330 
331         g.Key,
332 
333         g
334 
335       };
336 
337  
338 
339 语句描述:使用Group By按CategoryID和 SupplierID将产品分组。
340 
341  
342 
343 说明:既按产品的分类,又按供应商分类。在 by后面,new出来一个匿名类。这里,Key其实质是一个类的对象,Key包含两个 Property:CategoryID、SupplierID。用g.Key.CategoryID可以遍历CategoryID 的值。
344 
345  
346 
347 11.表达式(Expression)
348 
349  
350 
351 var categories =
352 
353    from p in db.Products
354 
355   group p by new { Criterion = p.UnitPrice > 10 } into g
356 
357   select g;
358 
359  
360 
361 语句描述:使用Group By返回两个产品序列。第一个序列包含单价大于10的产品。第二个序列包含单价小于或等于10的产品。
362 
363  
364 
365 说明:按产品单价是否大于10分类。其结果分为两类,大于的是一类,小于及等于为另一类。
Group By/Having 分组查询

 

LINQ to SQL语句(7)之Exists/In/Any/All/Contains

Exists/In/Any/All/Contains操作符

 

适用场景:用于判断集合中元素,进一步缩小范围。

 

 

  1 Any
  2 
  3  
  4 
  5 说明:用于判断集合中是否有元素满足某一条件;不延迟。(若条件为空,则集合只要不为空就返回True,否则为 False)。有2种形式,分别为简单形式和带条件形式。
  6 
  7  
  8 
  9 1.简单形式:
 10 
 11  
 12 
 13 仅返回没有订单的客户:
 14 
 15  
 16 
 17 var q =
 18 
 19   from c in db.Customers
 20 
 21   where !c.Orders.Any()
 22 
 23   select c;
 24 
 25  
 26 
 27 生成SQL语句为:
 28 
 29  
 30 
 31 SELECT [t0].[CustomerID],[t0].[CompanyName], [t0].[ContactName],
 32 
 33 [t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region],
 34 
 35 [t0].[PostalCode], [t0].[Country],[t0].[Phone], [t0].[Fax]
 36 
 37 FROM [dbo].[Customers] AS [t0]
 38 
 39 WHERE NOT (EXISTS(
 40 
 41   SELECT NULL AS [EMPTY] FROM [dbo].[Orders] AS [t1]
 42 
 43   WHERE [t1].[CustomerID] = [t0]. [CustomerID]
 44 
 45   ))
 46 
 47  
 48 
 49 2.带条件形式:
 50 
 51  
 52 
 53 仅返回至少有一种产品断货的类别:
 54 
 55  
 56 
 57 var q =
 58 
 59   from c in db.Categories
 60 
 61   where c.Products.Any(p => p.Discontinued)
 62 
 63   select c;
 64 
 65  
 66 
 67 生成SQL语句为:
 68 
 69  
 70 
 71 SELECT [t0]. [CategoryID],[t0].[CategoryName], [t0].[Description],
 72 
 73 [t0]. [Picture] FROM [dbo].[Categories] AS[t0]
 74 
 75 WHERE EXISTS(
 76 
 77    SELECT NULL AS [EMPTY] FROM [dbo].[Products] AS [t1]
 78 
 79   WHERE ([t1].[Discontinued] = 1) AND
 80 
 81   ([t1].[CategoryID] = [t0]. [CategoryID])
 82 
 83   )
 84 
 85 All
 86 
 87 说明:用于判断集合中所有元素是否都满足某一条件;不延迟1.带条件形式
 88 
 89  
 90 
 91 var q =
 92 
 93   from c in db.Customers
 94 
 95   where c.Orders.All(o => o.ShipCity == c.City)
 96 
 97   select c;
 98 
 99  
100 
101 语句描述:这个例子返回所有订单都运往其所在城市的客户或未下订单的客户。
102 
103  
104 
105 Contains
106 
107  
108 
109 说明:用于判断集合中是否包含有某一元素;不延迟。它是对两个序列进行连接操作的。
110 
111  
112 
113 string[] customerID_Set =
114 
115   new string[] { "AROUT", "BOLID","FISSA" };
116 
117 var q = (
118 
119   from o in db.Orders
120 
121   where customerID_Set.Contains(o.CustomerID)
122 
123   select o).ToList ();
124 
125  
126 
127 语句描述:查找"AROUT", "BOLID""FISSA" 这三个客户的订单。先定义了一个数组,在LINQ to SQL中使用Contains,数组中包含了所有的CustomerID,即返回结果中,所有的 CustomerID都在这个集合内。也就是in。你也可以把数组的定义放在LINQ to SQL语句里。比如:
128 
129  
130 
131 var q = (
132 
133   from o in db.Orders
134 
135   where (
136 
137   new string[] { "AROUT", "BOLID","FISSA" })
138 
139   .Contains (o.CustomerID)
140 
141   select o).ToList();
142 
143 Not Contains则取反:
144 
145 var q = (
146 
147   from o in db.Orders
148 
149   where !(
150 
151   new string[] { "AROUT", "BOLID","FISSA" })
152 
153   .Contains(o.CustomerID)
154 
155   select o).ToList();
156 
157  
158 
159 1.包含一个对象:
160 
161  
162 
163 var order = (from o in db.Orders
164 
165        where o.OrderID == 10248
166 
167        select o).First();
168 
169 var q = db.Customers.Where(p =>p.Orders.Contains(order)).ToList();
170 
171 foreach (var cust in q)
172 
173 {
174 
175   foreach (var ord in cust.Orders)
176 
177   {
178 
179     //do something
180 
181   }
182 
183 }
184 
185  
186 
187 语句描述:这个例子使用Contain查找哪个客户包含OrderID为10248的订单。
188 
189  
190 
191 2.包含多个值:
192 
193  
194 
195 string[] cities =
196 
197   new string[] { "Seattle", "London","Vancouver", "Paris" };
198 
199 var q = db.Customers.Where(p=>cities.Contains(p.City)).ToList();
200 
201  
202 
203 语句描述:这个例子使用Contains查找其所在城市为西雅图、伦敦、巴黎或温哥华的客户
Exists/In/Any/All/Contains

LINQ to SQL语句(8)之Concat/Union/Intersect/Except

Concat/Union/Intersect/Except操作

 

适用场景:对两个集合的处理,例如追加、合并、取相同项、相交项等等。

 

  1 Concat(连接)
  2 
  3  
  4 
  5 说明:连接不同的集合,不会自动过滤相同项;延迟。
  6 
  7  
  8 
  9 1.简单形式:
 10 
 11 var q = (
 12 
 13      from c in db.Customers
 14 
 15      select c.Phone
 16 
 17     ).Concat(
 18 
 19      from c in db.Customers
 20 
 21      select c.Fax
 22 
 23     ).Concat(
 24 
 25      from e in db.Employees
 26 
 27      select e.HomePhone
 28 
 29     );
 30 
 31  
 32 
 33 语句描述:返回所有消费者和雇员的电话和传真。
 34 
 35  
 36 
 37 2.复合形式:
 38 
 39 var q = (
 40 
 41      from c in db.Customers
 42 
 43      select new
 44 
 45      {
 46 
 47        Name = c.CompanyName,
 48 
 49        c.Phone
 50 
 51      }
 52 
 53      ).Concat(
 54 
 55      from e in db.Employees
 56 
 57      select new
 58 
 59      {
 60 
 61        Name = e.FirstName + " " + e.LastName,
 62 
 63        Phone = e.HomePhone
 64 
 65      }
 66 
 67     );
 68 
 69  
 70 
 71 语句描述:返回所有消费者和雇员的姓名和电话。
 72 
 73  
 74 
 75 Union(合并)
 76 
 77  
 78 
 79 说明:连接不同的集合,自动过滤相同项;延迟。即是将两个集合进行合并操作,过滤相同的项。
 80 
 81  
 82 
 83 var q = (
 84 
 85      from c in db.Customers
 86 
 87      select c.Country
 88 
 89     ).Union(
 90 
 91      from e in db.Employees
 92 
 93      select e.Country
 94 
 95     );
 96 
 97  
 98 
 99 语句描述:查询顾客和职员所在的国家。
100 
101  
102 
103 Intersect(相交)
104 
105  
106 
107 说明:取相交项;延迟。即是获取不同集合的相同项(交集)。即先遍历第一个集合,找出所有唯一的元素,然后遍历第二个集合,并将每个元素与前面找出的元素作对比,返回所有在两个集合内都出现的元素。
108 
109  
110 
111 var q = (
112 
113      from c in db.Customers
114 
115      select c.Country
116 
117     ).Intersect (
118 
119      from e in db.Employees
120 
121      select e.Country
122 
123     );
124 
125  
126 
127 语句描述:查询顾客和职员同在的国家。
128 
129  
130 
131 Except(与非)
132 
133  
134 
135 说明:排除相交项;延迟。即是从某集合中删除与另一个集合中相同的项。先遍历第一个集合,找出所有唯一的元素,然后再遍历第二个集合,返回第二个集合中所有未出现在前面所得元素集合中的元素。
136 
137  
138 
139 var q = (
140 
141      from c in db.Customers
142 
143      select c.Country
144 
145     ).Except(
146 
147      from e in db.Employees
148 
149      select e.Country
150 
151     );
152 
153  
154 
155 语句描述:查询顾客和职员不同的国家。
Concat/Union/Intersect/Except

 

 

 

LINQ to SQL语句(9)之Top/Bottom和Paging分页和SqlMethods

Top/Bottom操作(Take,Skip)

 

 

 

适用场景:适量的取出自己想要的数据,不是全部取出,这样性能有所加强。

 

  1 Take
  2 
  3  
  4 
  5 说明:获取集合的前n个元素;延迟。即只返回限定数量的结果集。
  6 
  7  
  8 
  9 var q = (
 10 
 11   from e in db.Employees
 12 
 13   orderby e.HireDate
 14 
 15   select e)
 16 
 17   .Take(5);
 18 
 19  
 20 
 21 语句描述:选择所雇用的前5个雇员。
 22 
 23  
 24 
 25 Skip
 26 
 27  
 28 
 29 说明:跳过集合的前n个元素;延迟。即我们跳过给定的数目返回后面的结果集。
 30 
 31  
 32 
 33 var q = (
 34 
 35   from p in db.Products
 36 
 37   orderby p.UnitPrice descending
 38 
 39   select p)
 40 
 41   .Skip (10);
 42 
 43  
 44 
 45 语句描述:选择10种最贵产品之外的所有产品。
 46 
 47  
 48 
 49 TakeWhile
 50 
 51  
 52 
 53 说明:直到某一条件成立就停止获取;延迟。即用其条件去依次判断源序列中的元素,返回符合判断条件的元素,该判断操作将在返回 false或源序列的末尾结束。
 54 
 55  
 56 
 57 SkipWhile
 58 
 59  
 60 
 61 说明:直到某一条件成立就停止跳过;延迟。即用其条件去判断源序列中的元素并且跳过第一个符合判断条件的元素,一旦判断返回false,接下来将不再进行判断并返回剩下的所有元素。
 62 
 63  
 64 
 65 Paging(分页)操作
 66 
 67  
 68 
 69 适用场景:结合Skip和Take就可实现对数据分页操作。
 70 
 71  
 72 
 73 1.索引
 74 
 75 var q = (
 76 
 77   from c in db.Customers
 78 
 79   orderby c.ContactName
 80 
 81   select c)
 82 
 83   .Skip(50)
 84 
 85   .Take(10);
 86 
 87  
 88 
 89 语句描述:使用Skip和Take运算符进行分页,跳过前50条记录,然后返回接下来10条记录,因此提供显示 Products表第6页的数据。
 90 
 91  
 92 
 93 2.按唯一键排序
 94 
 95 var q = (
 96 
 97    from p in db.Products
 98 
 99   where p.ProductID > 50
100 
101    orderby p.ProductID
102 
103   select p)
104 
105   .Take(10);
106 
107  
108 
109 语句描述:使用Where子句和Take运算符进行分页,首先筛选得到仅50 (第5页最后一个ProductID)以上的ProductID,然后按ProductID排序,最后取前10个结果,因此提供Products表第6页的数据。请注意,此方法仅适用于按唯一键排序的情况。
110 
111  
112 
113 SqlMethods操作
114 
115  
116 
117 在LINQ to SQL语句中,为我们提供了 SqlMethods操作,进一步为我们提供了方便,例如Like方法用于自定义通配表达式,Equals用于相比较是否相等。
118 
119  
120 
121 Like
122 
123  
124 
125 自定义的通配表达式。%表示零长度或任意长度的字符串;_表示一个字符;[]表示在某范围区间的一个字符;[^]表示不在某范围区间的一个字符。比如查询消费者ID以“C”开头的消费者。
126 
127  
128 
129 var q = from c in db.Customers
130 
131      where SqlMethods.Like(c.CustomerID, "C%")
132 
133      select c;
134 
135  
136 
137 比如查询消费者ID没有“AXOXT”形式的消费者:
138 
139  
140 
141 var q = from c in db.Customers
142 
143     where ! SqlMethods.Like(c.CustomerID, "A_O_T")
144 
145     select c;
146 
147 DateDiffDay
148 
149  
150 
151 说明:在两个变量之间比较。分别有:DateDiffDay、 DateDiffHour、DateDiffMillisecond、DateDiffMinute、DateDiffMonth、 DateDiffSecond、DateDiffYear 
152 
153  
154 
155 var q = from o in db.Orders
156 
157     where SqlMethods
158 
159     .DateDiffDay (o.OrderDate, o.ShippedDate) < 10
160 
161     select o;
162 
163  
164 
165 语句描述:查询在创建订单后的 10 天内已发货的所有订单。
166 
167  
168 
169 已编译查询操作(Compiled Query)
170 
171  
172 
173 说明:在之前我们没有好的方法对写出的SQL语句进行编辑重新查询,现在我们可以这样做,看下面一个例子:
174 
175  
176 
177 //1. 创建compiled query
178 
179 NorthwindDataContext db = newNorthwindDataContext();
180 
181 var fn = CompiledQuery.Compile(
182 
183    (NorthwindDataContext db2, string city) =>
184 
185   from c in db2.Customers
186 
187   where c.City == city
188 
189   select c);
190 
191 //2.查询城市为London的消费者,用LonCusts集合表示,这时可以用数据控件 绑定
192 
193 var LonCusts = fn(db, "London");
194 
195 //3.查询城市 为Seattle的消费者
196 
197 var SeaCusts = fn(db, "Seattle");
198 
199  
200 
201 语句描述:这个例子创建一个已编译查询,然后使用它检索输入城市的客户。
条件查询

 

LINQ to SQL语句(10)之Insert

插入(Insert)

 

  1 1.简单形式
  2 
  3 说明:new一个对象,使用InsertOnSubmit方法将其加入到对应的集合中,使用SubmitChanges()提交到数据库。
  4 
  5  
  6 
  7 NorthwindDataContext db = newNorthwindDataContext();
  8 
  9 var newCustomer = new Customer
 10 
 11 {
 12 
 13   CustomerID = "MCSFT",
 14 
 15   CompanyName = "Microsoft",
 16 
 17   ContactName = "John Doe",
 18 
 19   ContactTitle = "Sales Manager",
 20 
 21   Address = "1 Microsoft Way",
 22 
 23   City = "Redmond",
 24 
 25   Region = "WA",
 26 
 27   PostalCode = "98052",
 28 
 29    Country = "USA",
 30 
 31   Phone = "(425) 555- 1234",
 32 
 33   Fax = null
 34 
 35 };
 36 
 37 db.Customers.InsertOnSubmit(newCustomer);
 38 
 39 db.SubmitChanges ();
 40 
 41  
 42 
 43 语句描述:使用InsertOnSubmit方法将新客户添加到Customers 表对象。调用SubmitChanges 将此新Customer保存到数据库。
 44 
 45  
 46 
 47 2.一对多关系
 48 
 49  
 50 
 51 说明:Category与Product是一对多的关系,提交Category(一端)的数据时,LINQ to SQL会自动将Product(多端)的数据一起提交。
 52 
 53  
 54 
 55 var newCategory = new Category
 56 
 57 {
 58 
 59   CategoryName = "Widgets",
 60 
 61   Description = "Widgets are the ……"
 62 
 63 };
 64 
 65 var newProduct = new Product
 66 
 67 {
 68 
 69   ProductName = "Blue Widget",
 70 
 71   UnitPrice = 34.56M,
 72 
 73   Category = newCategory
 74 
 75 };
 76 
 77 db.Categories.InsertOnSubmit(newCategory);
 78 
 79 db.SubmitChanges ();
 80 
 81  
 82 
 83 语句描述:使用InsertOnSubmit方法将新类别添加到Categories 表中,并将新Product对象添加到与此新Category有外键关系的Products表中。调用SubmitChanges将这些新对象及其关系保存到数据库。
 84 
 85  
 86 
 87 3.多对多关系
 88 
 89  
 90 
 91 说明:在多对多关系中,我们需要依次提交。
 92 
 93  
 94 
 95 var newEmployee = new Employee
 96 
 97 {
 98 
 99   FirstName = "Kira",
100 
101   LastName = "Smith"
102 
103 };
104 
105 var newTerritory = new Territory
106 
107 {
108 
109   TerritoryID = "12345",
110 
111   TerritoryDescription = "Anytown",
112 
113   Region = db.Regions.First()
114 
115 };
116 
117 var newEmployeeTerritory = newEmployeeTerritory
118 
119 {
120 
121    Employee = newEmployee,
122 
123   Territory = newTerritory
124 
125 };
126 
127 db.Employees.InsertOnSubmit(newEmployee);
128 
129 db.Territories.InsertOnSubmit(newTerritory);
130 
131 db.EmployeeTerritories.InsertOnSubmit(newEmployeeTerritory);
132 
133 db.SubmitChanges();
134 
135  
136 
137 语句描述:使用InsertOnSubmit方法将新雇员添加到Employees 表中,将新Territory添加到Territories表中,并将新 EmployeeTerritory对象添加到与此新Employee对象和新Territory对象有外键关系的EmployeeTerritories表中。调用SubmitChanges将这些新对象及其关系保持到数据库。
138 
139  
140 
141 4.使用动态CUD重写(Overrideusing Dynamic CUD)
142 
143  
144 
145 说明:CUD就是Create、Update、Delete的缩写。下面的例子就是新建一个ID(主键) 为32的Region,不考虑数据库中有没有ID为32的数据,如果有则替换原来的数据,没有则插入。
146 
147  
148 
149 Region nwRegion = new Region()
150 
151 {
152 
153   RegionID = 32,
154 
155   RegionDescription = "Rainy"
156 
157 };
158 
159 db.Regions.InsertOnSubmit(nwRegion);
160 
161 db.SubmitChanges ();
162 
163  
164 
165 语句描述:使用DataContext提供的分部方法InsertRegion插入一个区域。对SubmitChanges 的调用调用InsertRegion 重写,后者使用动态CUD运行Linq To SQL生成的默认SQL查询。
Insert 插入

 

LINQ to SQL语句(11)之Update

更新(Update)

 

说明:更新操作,先获取对象,进行修改操作之后,直接调用SubmitChanges()方法即可提交。注意,这里是在同一个DataContext中,对于不同的DataContex看下面的讲解。

 

 1 1.简单形式
 2 
 3 Customer cust =
 4 
 5   db.Customers.First(c => c.CustomerID == "ALFKI");
 6 
 7 cust.ContactTitle = "VicePresident";
 8 
 9 db.SubmitChanges();
10 
11  
12 
13 语句描述:使用 SubmitChanges将对检索到的一个Customer对象做出的更新保持回数据库。
14 
15  
16 
17 2.多项更改
18 
19 var q = from p in db.Products
20 
21      where p.CategoryID == 1
22 
23     select p;
24 
25 foreach (var p in q)
26 
27 {
28 
29   p.UnitPrice += 1.00M;
30 
31 }
32 
33 db.SubmitChanges ();
34 
35  
36 
37 语句描述:使用SubmitChanges将对检索到的进行的更新保持回数据库。
更新(Update)

 

LINQ to SQL语句(12)之Delete和使用Attach

删除(Delete)

 

  1 1.简单形式
  2 
  3  
  4 
  5 说明:调用DeleteOnSubmit方法即可。
  6 
  7  
  8 
  9 OrderDetail orderDetail =
 10 
 11    db.OrderDetails.First
 12 
 13   (c => c.OrderID == 10255 && c.ProductID == 36);
 14 
 15 db.OrderDetails.DeleteOnSubmit(orderDetail);
 16 
 17 db.SubmitChanges();
 18 
 19  
 20 
 21 语句描述:使用 DeleteOnSubmit方法从OrderDetail 表中删除OrderDetail对象。调用 SubmitChanges 将此删除保持到数据库。
 22 
 23  
 24 
 25 2.一对多关系
 26 
 27  
 28 
 29 说明:Order 与OrderDetail是一对多关系,首先DeleteOnSubmit其OrderDetail(多端),其次 DeleteOnSubmit其Order(一端)。因为一端是主键。
 30 
 31  
 32 
 33 var orderDetails =
 34 
 35   from o in db.OrderDetails
 36 
 37   where o.Order.CustomerID == "WARTH" &&
 38 
 39    o.Order.EmployeeID == 3
 40 
 41   select o;
 42 
 43 var order =
 44 
 45    (from o in db.Orders
 46 
 47    where o.CustomerID == "WARTH" && o.EmployeeID ==3
 48 
 49    select o).First();
 50 
 51 foreach (OrderDetail od in orderDetails)
 52 
 53 {
 54 
 55    db.OrderDetails.DeleteOnSubmit(od);
 56 
 57 }
 58 
 59 db.Orders.DeleteOnSubmit(order);
 60 
 61 db.SubmitChanges();
 62 
 63  
 64 
 65 语句描述语句描述:使用DeleteOnSubmit方法从Order 和Order Details表中删除Order和Order Detail对象。首先从Order Details删除,然后从Orders删除。调用SubmitChanges将此删除保持到数据库。
 66 
 67  
 68 
 69 3.推理删除(Inferred Delete)
 70 
 71  
 72 
 73 说明:Order与OrderDetail是一对多关系,在上面的例子,我们全部删除CustomerID为WARTH和EmployeeID为3 的数据,那么我们不须全部删除呢?例如Order的OrderID为10248的OrderDetail有很多,但是我们只要删除 ProductID为11的OrderDetail。这时就用Remove方法。
 74 
 75  
 76 
 77 Order order = db.Orders.First(x =>x.OrderID == 10248);
 78 
 79 OrderDetail od =
 80 
 81   order.OrderDetails.First(d => d.ProductID == 11);
 82 
 83 order.OrderDetails.Remove(od);
 84 
 85 db.SubmitChanges();
 86 
 87  
 88 
 89 语句描述语句描述:这个例子说明在实体对象的引用实体将该对象从其EntitySet 中移除时,推理删除如何导致在该对象上发生实际的删除操作。仅当实体的关联映射将DeleteOnNull设置为true且CanBeNull 为false 时,才会发生推理删除行为。
 90 
 91  
 92 
 93 使用Attach更新(Updatewith Attach)
 94 
 95  
 96 
 97 说明:在对于在不同的 DataContext之间,使用Attach方法来更新数据。例如在一个名为tempdb的 NorthwindDataContext中,查询出Customer和Order,在另一个 NorthwindDataContext中,Customer的地址更新为123 First Ave,Order的 CustomerID 更新为CHOPS。
 98 
 99  
100 
101 //通常,通过从其他层反序列化 XML 来获取要附加的实体
102 
103 //不支持将实体从一个DataContext附加到另一个DataContext
104 
105 //因此若要复制反序列化实体的操作,将在此处重新创建这 些实体
106 
107 Customer c1;
108 
109 List<Order> deserializedOrders = newList<Order>();
110 
111 Customer deserializedC1;
112 
113 using (NorthwindDataContext tempdb = newNorthwindDataContext())
114 
115 {
116 
117   c1 = tempdb.Customers.Single(c => c.CustomerID =="ALFKI");
118 
119   deserializedC1 = new Customer
120 
121    {
122 
123     Address = c1.Address,
124 
125     City = c1.City,
126 
127     CompanyName = c1.CompanyName,
128 
129     ContactName = c1.ContactName,
130 
131     ContactTitle = c1.ContactTitle,
132 
133     Country = c1.Country,
134 
135     CustomerID = c1.CustomerID,
136 
137     Fax = c1.Fax,
138 
139     Phone = c1.Phone,
140 
141      PostalCode = c1.PostalCode,
142 
143     Region = c1.Region
144 
145   };
146 
147   Customer tempcust =
148 
149      tempdb.Customers.Single(c => c.CustomerID == "ANTON");
150 
151   foreach (Order o in tempcust.Orders)
152 
153   {
154 
155      deserializedOrders.Add(new Order
156 
157     {
158 
159        CustomerID = o.CustomerID,
160 
161       EmployeeID = o.EmployeeID,
162 
163       Freight = o.Freight,
164 
165        OrderDate = o.OrderDate,
166 
167       OrderID = o.OrderID,
168 
169       RequiredDate = o.RequiredDate,
170 
171       ShipAddress = o.ShipAddress,
172 
173       ShipCity = o.ShipCity,
174 
175       ShipName = o.ShipName,
176 
177       ShipCountry = o.ShipCountry,
178 
179       ShippedDate = o.ShippedDate,
180 
181       ShipPostalCode = o.ShipPostalCode,
182 
183       ShipRegion = o.ShipRegion,
184 
185       ShipVia = o.ShipVia
186 
187     });
188 
189   }
190 
191 }
192 
193 using (NorthwindDataContext db2 = newNorthwindDataContext())
194 
195 {
196 
197   //将第一个实体附加到当前数据上下文,以跟踪更改
198 
199   //对Customer更新,不能写错
200 
201    db2.Customers.Attach(deserializedC1);
202 
203   //更改所跟踪的实体
204 
205   deserializedC1.Address = "123 First Ave";
206 
207   // 附加订单列表中的所有实体
208 
209   db2.Orders.AttachAll (deserializedOrders);
210 
211   //将订单更新为属于其他客户
212 
213    foreach (Order o in deserializedOrders)
214 
215   {
216 
217      o.CustomerID = "CHOPS";
218 
219   }
220 
221   //在当前数据上下文中提交更改
222 
223   db2.SubmitChanges();
224 
225 }
226 
227  
228 
229 语句描述:从另一个层中获取实体,使用Attach和AttachAll将反序列化后的实体附加到数据上下文,然后更新实体。更改被提交到数据库。
230 
231  
232 
233 使用Attach更新和删除(Update and Delete with Attach)
234 
235  
236 
237 说明:在不同的DataContext中,实现插入、更新、删除。看下面的一个例子:
238 
239  
240 
241 //通常,通过从其他层 反序列化XML获取要附加的实体
242 
243 //此示例使用 LoadWith 在一个查询中预 先加载客户和订单,
244 
245 //并禁用延迟加载
246 
247 Customer cust = null;
248 
249 using (NorthwindDataContext tempdb = newNorthwindDataContext())
250 
251 {
252 
253   DataLoadOptions shape = new DataLoadOptions();
254 
255    shape.LoadWith<Customer>(c => c.Orders);
256 
257   //加载第一个客户实体及其订单
258 
259   tempdb.LoadOptions = shape;
260 
261    tempdb.DeferredLoadingEnabled = false;
262 
263   cust = tempdb.Customers.First(x => x.CustomerID =="ALFKI");
264 
265 }
266 
267 Order orderA = cust.Orders.First();
268 
269 Order orderB = cust.Orders.First(x =>x.OrderID > orderA.OrderID);
270 
271 using (NorthwindDataContext db2 = newNorthwindDataContext())
272 
273 {
274 
275   //将第一个实体附加到当前数据上下文,以跟踪更改
276 
277    db2.Customers.Attach(cust);
278 
279   //附加相关订单以进行跟踪; 否则将在提交时插入它们
280 
281   db2.Orders.AttachAll(cust.Orders.ToList ());
282 
283   //更新客户的Phone.
284 
285   cust.Phone = "2345 5436";
286 
287   //更新第一个订单OrderA的ShipCity.
288 
289    orderA.ShipCity = "Redmond";
290 
291   //移除第二个订单 OrderB.
292 
293   cust.Orders.Remove(orderB);
294 
295   //添加一个新的订单Order到客户Customer中.
296 
297   Order orderC = new Order() { ShipCity = "New York" };
298 
299   cust.Orders.Add (orderC);
300 
301   //提交执行
302 
303   db2.SubmitChanges();
304 
305 }
306 
307  
308 
309 语句描述:从一个上下文提取实体,并使用 Attach 和 AttachAll 附加来自其他上下文的实体,然后更新这两个实体,删除一个实体,添加另一个实体。更改被提交到数据库。
Delete 删除

 

LINQ to SQL语句(13)之开放式并发控制和事务

Simultaneous Changes开放式并发控制

下表介绍 LINQ to SQL 文档中涉及开放式并发的术语

 

 1 并发两个或更多用户同时尝试更新同一数据库行的情形。
 2 
 3 并发冲突两个或更多用户同时尝试向一行的一列或多列提交冲突值的情形。
 4 
 5 并发控制用于解决并发冲突的技术。
 6 
 7 开放式并发控制先调查其他事务是否已更改了行中的值,再允许提交更改的技术。相比之下,保守式并发控制则是通过锁定记录来避免发生并发冲突。之所以称作开放式控制,是因为它将一个事务干扰另一事务视为不太可能发生。
 8 
 9 冲突解决通过重新查询数据库刷新出现冲突的项,然后协调差异的过程。刷新对象时,LINQ to SQL 更改跟踪器会保留以下数据:最初从数据库获取并用于更新检查的值通过后续查询获得的新数据库值。 LINQ to SQL 随后会确定相应对象是否发生冲突(即它的一个或多个成员值是否已发生更改)。如果此对象发生冲突,LINQ to SQL 下一步会确定它的哪些成员发生冲突。LINQ to SQL 发现的任何成员冲突都会添加到冲突列表中。
10 
11  
12 
13  
14 
15 在 LINQ to SQL 对象模型中,当以下两个条件都得到满足时,就会发生“开放式并发冲突”:客户端尝试向数据库提交更改;数据库中的一个或多个更新检查值自客户端上次读取它们以来已得到更新。此冲突的解决过程包括查明对象的哪些成员发生冲突,然后决定您希望如何进行处理。
术语说明

 

开放式并发(Optimistic Concurrency)

 

 

说明:这个例子中在你读取数据之前,另外一个用户已经修改并提交更新了这个数据,所以不会出现冲突。

 

 1 //我们打开一个新的连接来模拟另外一个用户
 2 
 3 NorthwindDataContext otherUser_db = newNorthwindDataContext();
 4 
 5 var otherUser_product =
 6 
 7   otherUser_db.Products.First(p => p.ProductID == 1);
 8 
 9 otherUser_product.UnitPrice = 999.99M;
10 
11 otherUser_db.SubmitChanges();
12 
13 //我们当前连接
14 
15 var product = db.Products.First(p =>p.ProductID == 1);
16 
17 product.UnitPrice = 777.77M;
18 
19 try
20 
21 {
22 
23   db.SubmitChanges();//当前连接执行成功
24 
25 }
26 
27 catch (ChangeConflictException)
28 
29 {
30 
31 }
32 
33  
34 
35 说明:我们读取数据之后,另外一个用户获取并提交更新了这个数据,这时,我们更新这个数据时,引起了一个并发冲突。系统发生回滚,允许你可以从数据库检索新更新的数据,并决定如何继续进行您自己的更新。
36 
37  
38 
39 //当前 用户
40 
41 var product = db.Products.First(p =>p.ProductID == 1);
42 
43 //我们打开一个新的连接来模拟另外一个用户
44 
45 NorthwindDataContext otherUser_db = newNorthwindDataContext() ;
46 
47 var otherUser_product =
48 
49   otherUser_db.Products.First(p => p.ProductID == 1);
50 
51 otherUser_product.UnitPrice = 999.99M;
52 
53 otherUser_db.SubmitChanges();
54 
55 //当前用户修改
56 
57 product.UnitPrice = 777.77M;
58 
59 try
60 
61 {
62 
63    db.SubmitChanges();
64 
65 }
66 
67 catch (ChangeConflictException)
68 
69 {
70 
71   //发生异常!
72 
73 }
开放式并发

 

Transactions事务

LINQto SQL 支持三种事务模型,分别是:

 1 显式本地事务:调用 SubmitChanges 时,如果 Transaction 属性设置为事务,则在同一事务的上下文中执行 SubmitChanges 调用。成功执行事务后,要由您来提交或回滚事务。与事务对应的连接必须与用于构造 DataContext 的连接匹配。如果使用其他连接,则会引发异常。
 2 
 3  
 4 
 5 显式可分发事务:可以在当前 Transaction 的作用域中调用 LINQ to SQL API(包括但不限于 SubmitChanges)。LINQ to SQL 检测到调用是在事务的作用域内,因而不会创建新的事务。在这种情况下, <token>vbtecdlinq</token> 还会避免关闭连接。您可以在此类事 务的上下文中执行查询和SubmitChanges 操作。
 6 
 7  
 8 
 9 隐式事务:当您调用 SubmitChanges 时,LINQ to SQL 会检查此调用是否在 Transaction 的作用域内或者 Transaction 属性是否设置为由用户启动的本地事务。如果这两个事务它均未找到,则 LINQ to SQL 启动本地事务,并使用此事务执行所生成的 SQL 命令。当所有 SQL 命令均已成功执行完毕时,LINQ to SQL 提交本地事务并返回。
10 
11  
12 
13 1.Implicit(隐式)
14 
15  
16 
17 说明:这个例子在执行SubmitChanges ()操作时,隐式地使用了事务。因为在更新2种产品的库存数量时,第二个产品库存数量为负数了,违反了服务器上的 CHECK 约束。这导致了更新产品全部失败了,系统回滚到这个操作的初始状态。
18 
19 try
20 
21 {
22 
23   Product prod1 = db.Products.First(p => p.ProductID == 4);
24 
25   Product prod2 = db.Products.First(p => p.ProductID == 5);
26 
27    prod1.UnitsInStock -= 3;
28 
29   prod2.UnitsInStock -= 5;//错误:库存 数量的单位不能是负数
30 
31   //要么全部成功要么全部失败
32 
33    db.SubmitChanges();
34 
35 }
36 
37 catch (System.Data.SqlClient.SqlExceptione)
38 
39 {
40 
41   //执行异常处理
42 
43 }
44 
45  
46 
47 2.Explicit(显式)
48 
49  
50 
51 说明:这个例子使用显式事务。通过在事务中加入对数据的读取以防止出现开放式并发异常,显式事务可以提供更多的保护。如同上一个查询中,更新 prod2 的 UnitsInStock 字段将使该字段为负值,而这违反了数据库中的 CHECK 约束。这导致更新这两个产品的事务失败,此时将回滚所有更改。
52 
53  
54 
55 using (TransactionScope ts = new TransactionScope())
56 
57 {
58 
59   try
60 
61   {
62 
63      Product prod1 = db.Products.First(p => p.ProductID == 4);
64 
65     Product prod2 = db.Products.First(p => p.ProductID == 5);
66 
67     prod1.UnitsInStock -= 3;
68 
69     prod2.UnitsInStock -= 5;//错误:库存数量的单位不能是负数
70 
71     db.SubmitChanges();
72 
73   }
74 
75   catch (System.Data.SqlClient.SqlException e)
76 
77   {
78 
79     //执行异常处理
80 
81   }
82 
83 }
事务

LINQ to SQL语句(14)之Null语义和DateTime

Null语义

 

说明:下面第一个例子说明查询ReportsToEmployee为null的雇员。第二个例子使用Nullable<T>.HasValue查询雇员,其结果与第一个例 子相同。在第三个例子中,使用Nullable<T>.Value来返回ReportsToEmployee不为null的雇员的ReportsTo的值。

 1 1.Null
 2 
 3  
 4 
 5 查找不隶属于另一个雇员的所有雇员:
 6 
 7  
 8 
 9 var q =
10 
11   from e in db.Employees
12 
13   where e.ReportsToEmployee == null
14 
15    select e;
16 
17 2.Nullable<T>.HasValue
18 
19  
20 
21 查找不隶属于另一个雇员的所有雇员:
22 
23  
24 
25 var q =
26 
27   from e in db.Employees
28 
29   where !e.ReportsTo.HasValue
30 
31   select e;
32 
33 3.Nullable<T>.Value
34 
35  
36 
37 返回前者的EmployeeID 编号。请注意 .Value 为可选:
38 
39  
40 
41 var q =
42 
43   from e in db.Employees
44 
45   where e.ReportsTo.HasValue
46 
47   select new
48 
49   {
50 
51     e.FirstName,
52 
53     e.LastName,
54 
55     ReportsTo = e.ReportsTo.Value
56 
57   };
Null

日期函数

 

LINQ to SQL支持以下 DateTime方法。但是,SQLServer和CLR的DateTime类型在范围和计时周期精度上不同,如下表。

 

类型最小值 最大 值 计时周期

System.DateTime 0001 年 1 月 1 日 9999 年 12 月 31 日 100 毫微秒(0.0000001秒)

T-SQL DateTime 1753 年 1 月 1 日 9999 年 12 月 31 日 3.33… 毫秒(0.0033333 秒)

T-SQL SmallDateTime 1900 年 1 月 1 日 2079 年 6 月 6 日 1 分钟(60 秒)

 

 

CLR DateTime 类型与SQL Server类型相比,前者范围更 大、精度更高。因此来自SQLServer的数据用CLR类型表示时,绝不会损失量值或精度。但如果反过来的话,则范围可能会减小,精度可能会降低;SQL Server 日期不存在TimeZone概念,而在CLR中支持这个功能。

 

我们在LINQ to SQL查询使用以当地时间、UTC 或固定时间要自己执行转换。

 

下面用三个实例说明一下。

 1 1.DateTime.Year
 2 
 3 var q =
 4 
 5   from o in db.Orders
 6 
 7   where o.OrderDate.Value.Year == 1997
 8 
 9    select o;
10 
11  
12 
13 语句描述:这个例子使用DateTime 的Year 属性查找1997 年下的订单。
1.DateTime.Year
 1 2.DateTime.Month
 2 
 3 var q =
 4 
 5   from o in db.Orders
 6 
 7   where o.OrderDate.Value.Month == 12
 8 
 9   select o;
10 
11  
12 
13 语句描述:这个例子使用DateTime的Month属性查找十二月下的订单。
2.DateTime.Month
 1 3.DateTime.Day
 2 
 3 var q =
 4 
 5   from o in db.Orders
 6 
 7   where o.OrderDate.Value.Day == 31
 8 
 9   select o;
10 
11  
12 
13 语句描述:这个例子使用DateTime的Day属性查找某月 31 日下的订单。
3.DateTime.Day

LINQ to SQL语句(15)之String

字符串(String)

 

LINQ to SQL支持以下String方法。但是不同的是默认 情况下System.String方法区分大小写。而SQL则不区分大小写。

 1 1.字符串串联(StringConcatenation)
 2 
 3 var q =
 4 
 5   from c in db.Customers
 6 
 7   select new
 8 
 9   {
10 
11      c.CustomerID,
12 
13     Location = c.City + ", " + c.Country
14 
15   };
16 
17  
18 
19 语句描述:这个例子使用+运算符在形成经计算得出的客户Location值过程中将字符串字段和字符串串联在一起。
1.字符串串联(StringConcatenation)
 1 2.String.Length
 2 
 3 var q =
 4 
 5   from p in db.Products
 6 
 7   where p.ProductName.Length < 10
 8 
 9   select p;
10 
11  
12 
13 语句描述:这个例子使用Length属性查找名称短于10个字符的所有产品。
2.String.Length
 1 3.String.Contains(substring)
 2 
 3 var q =
 4 
 5   from c in db.Customers
 6 
 7   where c.ContactName.Contains ("Anders")
 8 
 9   select c;
10 
11  
12 
13 语句描述:这个例子使用Contains方法查找所有其联系人姓名中包含“Anders”的客户。
3.String.Contains(substring)
 1 4.String.IndexOf(substring)
 2 
 3 var q =
 4 
 5   from c in db.Customers
 6 
 7   select new
 8 
 9   {
10 
11      c.ContactName,
12 
13     SpacePos = c.ContactName.IndexOf(" ")
14 
15   };
16 
17  
18 
19 语句描述:这个例子使用IndexOf方法查找每个客户联系人姓名中出现第一个空格的位置。
4.String.IndexOf(substring)
 1 5.String.StartsWith (prefix)
 2 
 3 var q =
 4 
 5   from c in db.Customers
 6 
 7   where c.ContactName.StartsWith("Maria")
 8 
 9   select c;
10 
11  
12 
13 语句描述:这个例子使用StartsWith方法查找联系人姓名以“Maria”开头的客户。
5.String.StartsWith (prefix)
 1 6.String.EndsWith(suffix)
 2 
 3 var q =
 4 
 5   from c in db.Customers
 6 
 7   where c.ContactName.EndsWith("Anders")
 8 
 9   select c;
10 
11  
12 
13 语句描述:这个例子使用EndsWith方法查找联系人姓名以“Anders”结尾的客户。
6.String.EndsWith(suffix)
 1 7.String.Substring(start)
 2 
 3 var q =
 4 
 5   from p in db.Products
 6 
 7   select p.ProductName.Substring(3);
 8 
 9  
10 
11 语句描述:这个例子使用Substring方法返回产品名称中从第四个字母开始的部分。
7.String.Substring(start)
 1 8.String.Substring (start, length)
 2 
 3 var q =
 4 
 5   from e in db.Employees
 6 
 7    where e.HomePhone.Substring(6, 3) == "555"
 8 
 9   select e;
10 
11  
12 
13 语句描述:这个例子使用Substring方法查找家庭电话号码第七位到第九位是“555”的雇员。
8.String.Substring (start, length)
 1 9.String.ToUpper()
 2 
 3 var q =
 4 
 5   from e in db.Employees
 6 
 7   select new
 8 
 9   {
10 
11     LastName = e.LastName.ToUpper(),
12 
13     e.FirstName
14 
15   };
16 
17  
18 
19 语句描述:这个例子使用ToUpper方法返回姓氏已转换为大写的雇员姓名。
9.String.ToUpper()
 1 10.String.ToLower()
 2 
 3 var q =
 4 
 5   from c in db.Categories
 6 
 7   select c.CategoryName.ToLower();
 8 
 9  
10 
11 语句描述:这个例子使用ToLower方法返回已转换为小写的类别名称。
10.String.ToLower()
 1 11.String.Trim()
 2 
 3 var q =
 4 
 5   from e in db.Employees
 6 
 7   select e.HomePhone.Substring(0, 5).Trim ();
 8 
 9  
10 
11 语句描述:这个例子使用Trim方法返回雇员家庭电话号码的前五位,并移除前导和尾随空格。
11.String.Trim()
 1 12.String.Insert(pos, str)
 2 
 3 var q =
 4 
 5   from e in db.Employees
 6 
 7   where e.HomePhone.Substring(4, 1) == ")"
 8 
 9   select e.HomePhone.Insert(5, ":");
10 
11  
12 
13 语句描述:这个例子使用 Insert方法返回第五位为 ) 的雇员电话号码的序列,并在 ) 后面插入一个 :。
12.String.Insert(pos, str)
 1 13.String.Remove(start)
 2 
 3 var q =
 4 
 5   from e in db.Employees
 6 
 7   where e.HomePhone.Substring(4, 1) == ") "
 8 
 9   select e.HomePhone.Remove(9);
10 
11  
12 
13 语句描述:这个例子使用Remove方法返回第五位为 ) 的雇员电话号码的序列,并移除从第十个字符开始的所有字符。
13.String.Remove(start)
 1 14.String.Remove(start, length)
 2 
 3 var q =
 4 
 5   from e in db.Employees
 6 
 7   where e.HomePhone.Substring(4, 1) == ")"
 8 
 9   select e.HomePhone.Remove(0, 6);
10 
11  
12 
13 语句描述:这个例子使用Remove方法返回第五位为 ) 的雇员电话号码的序列,并移除前六个字符。
14.String.Remove(start, length)
 1 15.String.Replace(find, replace)
 2 
 3 var q =
 4 
 5   from s in db.Suppliers
 6 
 7   select new
 8 
 9   {
10 
11      s.CompanyName,
12 
13     Country = s.Country
14 
15     .Replace ("UK", "United Kingdom")
16 
17     .Replace ("USA", "United States of America")
18 
19   };
20 
21  
22 
23 语句描述:这个例子使用 Replace 方法返回 Country 字段中UK 被替换为 United Kingdom 以及USA 被替换为 United States of America 的供 应商信息
15.String.Replace(find, replace)

LINQ to SQL语句(16)之对象标识

 1 对象标识
 2 
 3  
 4 
 5 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。
 6 
 7  
 8 
 9 关系数据库表中的行不具有唯一标识。由于每一行都具有唯一的主键,因此任何两行都不会共用同一键值。
10 
11  
12 
13 实际上,通常我们是将数据从数据库中提取出来放入另一层中,应用程序在该层对数据进行处理。这就是 LINQ to SQL 支持的模型。将数据作为行从数据库中提取出来时,你不期望表示相同数据的两行实际上对应于相同的行实例。如果您查询特定客户两次,您将获得两行数据。每一行包含相同的信息。
14 
15  
16 
17 对于对象。你期望在你反复向 DataContext 索取相同的信息时,它实际上会为你提供同一对象实例。你将它们设计为层次结构或关系图。你希望像检索实物一样检索它们,而不希望仅仅因为你多次索要同一内容而收到大量的复制实例。
18 
19  
20 
21 在 LINQ to SQL 中, DataContext 管理对象标识。只要你从数据库中检索新行,该行就会由其主键记录到标识表中,并且会创建一个新的对象。只要您检索该行,就会将原始对象实例传递回应用程序。通过这种方式,DataContext 将数据库看到的标识(即主键)的概念转换成相应语言看到的标识(即实例)的概念。应用程序只看到处于第一次检索时的状态的对象。新数据如果不同,则会被丢弃。
22 
23  
24 
25 LINQ to SQL 使用此方法来管理本地对象的完整性,以支持开放式更新。由于在最初创建对象 后唯一发生的更改是由应用程序做出的,因此应用程序的意向是很明确的。如果在中间阶段外部某一方做了更改,则在调用 SubmitChanges() 时会识别出这些更改。
26 
27  
28 
29 以上来自MSDN,的确,看了有点“正规”,下面我用两个例子说明一下。
对象标识
 1 对象缓存
 2 
 3  
 4 
 5 在第一个示例中,如果我们执行同一查询两次,则每次都会收到对内存中同一对象的引用。很明显,cust1和cust2是同一个对象引用。
 6 
 7  
 8 
 9 Customer cust1 = db.Customers.First(c =>c.CustomerID == "BONAP");
10 
11 Customer cust2 = db.Customers.First(c =>c.CustomerID == "BONAP");
12 
13  
14 
15 下面的示例中,如果您执行返回数据库中同一行的不同查询,则您每次都会收到对内存中同一对象的引用。cust1和cust2是同一个对象引用,但是数据库查询了两次。
16 
17  
18 
19 Customer cust1 = db.Customers.First(c =>c.CustomerID == "BONAP");
20 
21 Customer cust2 = (
22 
23   from o in db.Orders
24 
25   where o.Customer.CustomerID == "BONAP"
26 
27   select o )
28 
29   .First()
30 
31   .Customer;
对象缓存

LINQ to SQL语句(17)之对象加载

 1 对象加载延迟加载
 2 
 3  
 4 
 5 在查询某对象时,实际上你只查询该对象。不会同时自动获取这个对象。这就是延迟加载。
 6 
 7  
 8 
 9 例如,您可能需要查看客户数据和订单数据。你最初不一定需要检索与每个客户有关的所有订单数据。其优点是你可以使用延迟加载将额外信息的检索操作延迟到你确实需要检索它们时再进行。请看下面的示例:检索出来CustomerID,就根据这个ID查询出OrderID。
10 
11  
12 
13 var custs =
14 
15    from c in db.Customers
16 
17    where c.City == "Sao Paulo"
18 
19    select c;
20 
21 //上面 的查询句法不会导致语句立即执行,仅仅是一个描述性的语句,
22 
23 只有需要的时候才会执行它
24 
25 foreach (var cust in custs)
26 
27 {
28 
29    foreach (var ord in cust.Orders)
30 
31   {
32 
33     //同时查看客户数据和订单数据
34 
35   }
36 
37 }
38 
39  
40 
41 语句描述:原始查询未请求数据,在所检索到各个对象的链接中导航如何能导致触发对数据库的新查询。
对象加载延迟加载
 1 预先加载:LoadWith 方法
 2 
 3  
 4 
 5 你如果想要同时查询出一些对象的集合的方法。LINQ to SQL 提供了 DataLoadOptions用于立即加载对象。方法包括:
 6 
 7  
 8 
 9 LoadWith 方法,用于立即加载与主目标相关的数据。
10 
11  
12 
13 AssociateWith 方法,用于筛选为特定关系检索到的对象。
14 
15  
16 
17 使用 LoadWith方法指定应同时检索与主目标相关的哪些数据。例如,如果你知道你需要有关客户的订单的信息,则可以使用 LoadWith 来确保在检索客户信息的同时检索订单信息。使用此方法可仅访问一次数据库,但同时获取两组信息。
18 
19  
20 
21 在下面的示例中,我们通过设置DataLoadOptions,来指示DataContext 在加载Customers的同时把对应的Orders一起加载,在执行查询时会检索位于Sao Paulo的所有 Customers 的所有 Orders。这样一来,连续访问 Customer 对象的 Orders 属性不会触发新的数据库查询。在执行时生成的SQL语句使用了左连接。
22 
23  
24 
25 NorthwindDataContext db = newNorthwindDataContext ();
26 
27 DataLoadOptions ds = new DataLoadOptions();
28 
29 ds.LoadWith<Customer>(p =>p.Orders);
30 
31 db.LoadOptions = ds;
32 
33 var custs = (
34 
35    from c in db2.Customers
36 
37    where c.City == "Sao Paulo"
38 
39    select c);
40 
41 foreach (var cust in custs)
42 
43 {
44 
45   foreach (var ord in cust.Orders)
46 
47   {
48 
49     Console.WriteLine ("CustomerID {0} has an OrderID {1}.",
50 
51        cust.CustomerID,
52 
53       ord.OrderID);
54 
55   }
56 
57 }
58 
59  
60 
61 语句描述:在原始查询过程中使用 LoadWith 请求相关数据,以便稍后在检索到的各个对象中导航时不需要对数据库进行额外的往返。
预先加载:LoadWith 方法

LINQ to SQL语句(18)之运算符转换

 1 1.AsEnumerable:将类型转换为泛型 IEnumerable
 2 
 3  
 4 
 5 使用 AsEnumerable<TSource> 可返回类型化为泛型 IEnumerable的参数。在 此示例中,LINQ toSQL(使用默认泛型 Query)会尝试将查询转换为 SQL 并在服务器上执行。但 where 子句引用用户定义的客户端方法 (isValidProduct),此方法无法转换为 SQL。
 6 
 7  
 8 
 9 解决方法是指定 where 的客户端泛型 IEnumerable<T> 实现以替换泛型 IQueryable<T>。可通过调用 AsEnumerable<TSource>运算符来执行此操作。
10 
11  
12 
13 var q =
14 
15   from p in db.Products.AsEnumerable()
16 
17   where isValidProduct(p)
18 
19   select p;
20 
21  
22 
23 语句描述:这个例子就是使用AsEnumerable以便使用Where的客户端IEnumerable实现,而不是默认的 IQueryable将在服务器上转换为SQL并执行的默认Query<T>实现。这很有必要,因为Where子句引用了用户定义的客户端方法isValidProduct,该方法不能转换为SQL。
1.AsEnumerable:将类型转换为泛型 IEnumerable
 1 2.ToArray:将序列转换为数组
 2 
 3  
 4 
 5 使用 ToArray <TSource>可从序列创建数组。
 6 
 7  
 8 
 9 var q =
10 
11   from c in db.Customers
12 
13   where c.City == "London"
14 
15    select c;
16 
17 Customer[] qArray = q.ToArray();
18 
19  
20 
21 语句描述:这个例子使用 ToArray 将查询直接计算为数组。
2.ToArray:将序列转换为数组
 1 3.ToList:将序列转换为泛型列表
 2 
 3  
 4 
 5 使用 ToList<TSource>可从序列创建泛型列表。下面的示例使用 ToList<TSource>直接将查询的计算结果放入泛型 List<T> 6 
 7  
 8 
 9 var q =
10 
11   from e in db.Employees
12 
13   where e.HireDate >= new DateTime(1994, 1, 1)
14 
15   select e;
16 
17 List<Employee> qList = q.ToList();
3.ToList:将序列转换为泛型列表
 1 4.ToDictionary:将序列转化为字典
 2 
 3  
 4 
 5 使用Enumerable.ToDictionary<TSource, TKey>方法可 以将序列转化为字典。TSource表示source中的元素的类型;TKey表示keySelector返回的键的类型。其返回一个包含键和值的Dictionary<TKey, TValue> 6 
 7  
 8 
 9 var q =
10 
11   from p in db.Products
12 
13   where p.UnitsInStock <= p.ReorderLevel && ! p.Discontinued
14 
15   select p;
16 
17 Dictionary<int, Product> qDictionary=
18 
19   q.ToDictionary(p => p.ProductID);
20 
21 foreach (int key in qDictionary.Keys)
22 
23 {
24 
25    Console.WriteLine(key);
26 
27 }
28 
29  
30 
31 语句描述:这个例子使用 ToDictionary 将查询和键表达式直接键表达式直接计算为 Dictionary<K, T>。
4.ToDictionary:将序列转化为字典

LINQ to SQL语句(19)之ADO.NETLINQ to SQL

ADO.NET与LINQ to SQL

 

它基于由 ADO.NET 提供程序模型提供的服务。因此,我们可以将 LINQ to SQL 代码与现有的 ADO.NET 应用程序混合在一起,将当前 ADO.NET 解决方案迁移到 LINQ to SQL。

 1 1.连接
 2 
 3  
 4 
 5 在创建 LINQ to SQL DataContext 时,可以提供现有 ADO.NET 连接。对DataContext 的所有操作(包括查询)都使用所提供的这个连接。如果此连接已经打开,则在您使用完此连接时,LINQ to SQL 会保持它的打开状态不变。我们始终可以访问此连接,另外还可以使用 Connection 属性自行关闭它。
 6 
 7  
 8 
 9 //新建一个 标准的ADO.NET连接:
10 
11 SqlConnection nwindConn = new SqlConnection(connString);
12 
13 nwindConn.Open();
14 
15 // ... 其它的ADO.NET数据操作 代码... //
16 
17 //利用现有的ADO.NET连接来创建一个DataContext:
18 
19 Northwind interop_db = new Northwind(nwindConn);
20 
21 var orders =
22 
23    from o in interop_db.Orders
24 
25    where o.Freight > 500.00M
26 
27    select o;
28 
29 //返回Freight>500.00M的订单
30 
31 nwindConn.Close();
32 
33  
34 
35 语句描述:这个例子使用预先存在的ADO.NET 连接创建Northwind对象,本例中的查询返回运费至少为500.00 的所有订单。
1.连接
 1 2.事务
 2 
 3  
 4 
 5 当我们已经启动了自己的数据库事务并且我们希望 DataContext 包含在内时,我们可以向 DataContext 提供此事务。
 6 
 7  
 8 
 9 通过 .NET Framework 创建事务的首选方法是使用 TransactionScope 对象。通过使用此方法,我们可以创建跨数据库及其他驻留在内存中的资源管理器执行的分布式事务。事务范围几乎不需要资源就可以启动。它们仅在事务范围内存在多个连接时才将自身提升为分布式事务。
10 
11  
12 
13 using (TransactionScope ts = newTransactionScope())
14 
15 {
16 
17   db.SubmitChanges();
18 
19   ts.Complete();
20 
21 }
22 
23  
24 
25 注意:不能将此方法用于所有数据库。例如,SqlClient 连接在针对 SQL Server 2000 服务器使用时无法提升系统事务。它采取的方法是,只要它发现有使用事务范围的情况,它就会自动向完整的分布式事务登记。
26 
27  
28 
29 下面用一个例子说明一下事务的使用方法。在这里,也说明了重用 ADO.NET 命令和 DataContext 之间的同一连接。
30 
31  
32 
33 var q =
34 
35    from p in db.Products
36 
37    where p.ProductID == 3
38 
39    select p;
40 
41 //使用LINQ to SQL查询出来
42 
43 //新建一个标准的ADO.NET连接:
44 
45 SqlConnection nwindConn = newSqlConnection(connString);
46 
47 nwindConn.Open();
48 
49 //利用现有的 ADO.NET连接来创建一个DataContext:
50 
51 Northwind interop_db = newNorthwind(nwindConn);
52 
53 SqlTransaction nwindTxn =nwindConn.BeginTransaction();
54 
55 try
56 
57 {
58 
59   SqlCommand cmd = new SqlCommand("UPDATE Products SET"
60 
61    +"QuantityPerUnit = 'single item' WHERE ProductID = 3");
62 
63   cmd.Connection = nwindConn;
64 
65    cmd.Transaction = nwindTxn;
66 
67   cmd.ExecuteNonQuery();
68 
69    interop_db.Transaction = nwindTxn;
70 
71   Product prod1 = interop_db.Products.First(p => p.ProductID == 4);
72 
73   Product prod2 = interop_db.Products.First(p => p.ProductID == 5);
74 
75    prod1.UnitsInStock -= 3;
76 
77   prod2.UnitsInStock -= 5;//这有一个错 误,不能为负数
78 
79   interop_db.SubmitChanges();
80 
81    nwindTxn.Commit();
82 
83 }
84 
85 catch (Exception e)
86 
87 {
88 
89   // 如果有一个错误,所有的操作回滚
90 
91   Console.WriteLine (e.Message);
92 
93 }
94 
95 nwindConn.Close();
96 
97  
98 
99 语句描述:这个例子使用预先存在的 ADO.NET 连接创建 Northwind 对象,然后与此对象共享一个 ADO.NET 事务。此事务既用于通过 ADO.NET 连接执行 SQL 命令,又用于通过 Northwind 对象提交更改。当事务因违反 CHECK 约束而中止时,将回滚所有更改,包括通过 SqlCommand 做出的更改,以及通过Northwind 对象做出的更改。
2.事务

LINQ to SQL语句(20)之存储过程

存储过程

 

在我们编写程序中,往往需要一些存储过程,在LINQ to SQL中怎么使用呢?也许比原来的更简单些。下面我们以NORTHWND.MDF数据库中自带的几个存储过程来理解一下。

 1 1.标量返回
 2 
 3  
 4 
 5 在数据库中,有名为 Customers Count By Region的存储过程。该存储过程返回顾客所在"WA"区域的数量。
 6 
 7  
 8 
 9 ALTER PROCEDURE [dbo]. [NonRowset]
10 
11   (@param1 NVARCHAR(15))
12 
13 AS
14 
15 BEGIN
16 
17   SET NOCOUNT ON;
18 
19    DECLARE @count int
20 
21    SELECT @count = COUNT(*)FROM Customers
22 
23    WHERECustomers.Region = @Param1
24 
25    RETURN @count
26 
27 END
28 
29  
30 
31 我们只要把这个存储过程拖到O/R设计器内,它自动生成了以下代码段:
32 
33  
34 
35 [Function(Name = "dbo.[Customers CountBy Region]")]
36 
37 public intCustomers_Count_By_Region([Parameter
38 
39 (DbType = "NVarChar (15)")]string param1)
40 
41 {
42 
43   IExecuteResult result = this.ExecuteMethodCall(this,
44 
45   ((MethodInfo) (MethodInfo.GetCurrentMethod())), param1);
46 
47   return ((int) (result.ReturnValue));
48 
49 }
50 
51  
52 
53 我们需要时,直接调用就可以了,例如:
54 
55  
56 
57 int count = db.CustomersCountByRegion("WA");
58 
59 Console.WriteLine(count);
60 
61  
62 
63 语句描述:这个实例使用存储过程返回在“WA”地区的客户数。
1.标量返回
 1 2.单一结果集
 2 
 3  
 4 
 5 从数据库中返回行集合,并包含用于筛选结果的输入参数。当我们执行 返回行集合的存储过程时,会用到结果类,它存储从存储过程中返回的结果。
 6 
 7  
 8 
 9 下面的示例表示一个存储过程,该存储过程返回客户行并使用输入参数来仅返回将“London”列为客户城市的那些行的固定几列。 
10 
11  
12 
13 ALTER PROCEDURE [dbo].[Customers By City]
14 
15    -- Add the parameters for the stored procedure here
16 
17    (@param1 NVARCHAR(20))
18 
19 AS
20 
21 BEGIN
22 
23    -- SET NOCOUNT ON added to prevent extra result sets from
24 
25    -- interfering with SELECT statements.
26 
27    SET NOCOUNT ON;
28 
29    SELECT CustomerID, ContactName, CompanyName, City from
30 
31    Customers as c where c.City=@param1
32 
33 END
34 
35  
36 
37 拖到O/R设计器内,它自动生成了以下代码段:
38 
39  
40 
41 [Function(Name="dbo.[Customers ByCity]")]
42 
43 publicISingleResult<Customers_By_CityResult> Customers_By_City(
44 
45 [Parameter(DbType="NVarChar(20)")]string param1)
46 
47 {
48 
49   IExecuteResult result = this.ExecuteMethodCall(this, (
50 
51   (MethodInfo) (MethodInfo.GetCurrentMethod())), param1);
52 
53   return ((ISingleResult<Customers_By_CityResult>)
54 
55    (result.ReturnValue));
56 
57 }
58 
59  
60 
61 我们用下面的代码调用:
62 
63  
64 
65 ISingleResult<Customers_By_CityResult>result =
66 
67 db.Customers_By_City("London");
68 
69 foreach (Customers_By_CityResult cust inresult)
70 
71 {
72 
73    Console.WriteLine("CustID={0}; City={1}",cust.CustomerID,
74 
75     cust.City);
76 
77 }
78 
79  
80 
81 语句描述:这个实例使用存储过程返回在伦敦的客户的 CustomerID和City。
2.单一结果集
  1 3.多个可能形状的单一结果集
  2 
  3  
  4 
  5 当存储过程可以返回多个结果形状时,返回类型无法强类型化为单个投影形状。尽管 LINQ to SQL 可以生成所有可能的投影类型,但它无法获知将以何种顺序返回它们。 ResultTypeAttribute 属性适用于返回多个结果类型的存储过程,用以指定该过程可以返回的类型的集合。
  6 
  7  
  8 
  9 在下面的 SQL 代码示例中,结果形状取决于输入(param1 = 1或param1 = 2)。我们不知道先返回哪个投影。
 10 
 11  
 12 
 13 ALTER PROCEDURE [dbo].[SingleRowset_MultiShape]
 14 
 15    -- Add the parameters for the stored procedure here
 16 
 17    (@param1 int )
 18 
 19 AS
 20 
 21 BEGIN
 22 
 23    -- SET NOCOUNT ON added to prevent extra result sets from
 24 
 25    -- interfering with SELECT statements.
 26 
 27    SET NOCOUNT ON;
 28 
 29    if(@param1 = 1)
 30 
 31    SELECT * from Customers as c where c.Region = 'WA'
 32 
 33    else if (@param1 = 2)
 34 
 35    SELECT CustomerID, ContactName, CompanyName from
 36 
 37    Customers as c where c.Region = 'WA'
 38 
 39 END
 40 
 41  
 42 
 43 拖到O/R 设计器内,它自动生成了以下代码段:
 44 
 45  
 46 
 47 [Function (Name="dbo.[Whole Or PartialCustomers Set]")]
 48 
 49 publicISingleResult<Whole_Or_Partial_Customers_SetResult>
 50 
 51 Whole_Or_Partial_Customers_Set([Parameter(DbType="Int")]
 52 
 53 System.Nullable<int> param1)
 54 
 55 {
 56 
 57    IExecuteResult result = this.ExecuteMethodCall(this,
 58 
 59    ((MethodInfo)(MethodInfo.GetCurrentMethod())), param1);
 60 
 61    return ((ISingleResult<Whole_Or_Partial_Customers_SetResult>)
 62 
 63   (result.ReturnValue));
 64 
 65 }
 66 
 67  
 68 
 69 但是,VS2008会把多结果集存储过程识别为单结果集的存储过程,默认生成的代码我们要手动修改一下,要求返回多个结果集,像这样:
 70 
 71  
 72 
 73 [Function(Name="dbo.[Whole Or PartialCustomers Set]")]
 74 
 75 [ResultType(typeof (WholeCustomersSetResult))]
 76 
 77 [ResultType(typeof(PartialCustomersSetResult))]
 78 
 79 public IMultipleResultsWhole_Or_Partial_Customers_Set([Parameter
 80 
 81 (DbType="Int")]System.Nullable<int> param1)
 82 
 83 {
 84 
 85   IExecuteResult result = this.ExecuteMethodCall(this,
 86 
 87    ((MethodInfo)(MethodInfo.GetCurrentMethod())), param1);
 88 
 89    return ((IMultipleResults)(result.ReturnValue));
 90 
 91 }
 92 
 93  
 94 
 95 我们分别定义了两个分部类,用于指定返回的类型。WholeCustomersSetResult类 如 下:
 96 
 97  
 98 
 99 public partial classWholeCustomersSetResult
100 
101 {
102 
103   private string _CustomerID;
104 
105   private string _CompanyName;
106 
107   private string _ContactName;
108 
109   private string _ContactTitle;
110 
111   private string _Address;
112 
113    private string _City;
114 
115   private string _Region;
116 
117    private string _PostalCode;
118 
119   private string _Country;
120 
121   private string _Phone;
122 
123   private string _Fax;
124 
125   public WholeCustomersSetResult()
126 
127   {
128 
129   }
130 
131   [Column (Storage = "_CustomerID", DbType ="NChar(5)")]
132 
133   public string CustomerID
134 
135   {
136 
137     get { return this._CustomerID; }
138 
139     set
140 
141     {
142 
143        if ((this._CustomerID != value))
144 
145         this._CustomerID = value;
146 
147     }
148 
149   }
150 
151   [Column(Storage = "_CompanyName", DbType ="NVarChar(40)")]
152 
153   public string CompanyName
154 
155   {
156 
157     get { return this._CompanyName; }
158 
159     set
160 
161     {
162 
163        if ((this._CompanyName != value))
164 
165          this._CompanyName = value;
166 
167     }
168 
169   }
170 
171   [Column (Storage = "_ContactName", DbType ="NVarChar(30) ")]
172 
173   public string ContactName
174 
175   {
176 
177      get { return this._ContactName; }
178 
179     set
180 
181     {
182 
183       if ((this._ContactName != value))
184 
185          this._ContactName = value;
186 
187     }
188 
189   }
190 
191   [Column (Storage = "_ContactTitle", DbType ="NVarChar(30) ")]
192 
193   public string ContactTitle
194 
195   {
196 
197      get { return this._ContactTitle; }
198 
199     set
200 
201     {
202 
203       if ((this._ContactTitle != value))
204 
205          this._ContactTitle = value;
206 
207     }
208 
209   }
210 
211    [Column(Storage = "_Address", DbType = "NVarChar(60)")]
212 
213   public string Address
214 
215   {
216 
217     get { return this._Address; }
218 
219     set
220 
221     {
222 
223       if ((this._Address != value))
224 
225         this._Address = value;
226 
227     }
228 
229   }
230 
231   [Column(Storage = "_City", DbType = "NVarChar(15)")]
232 
233   public string City
234 
235   {
236 
237     get { return this._City; }
238 
239     set
240 
241     {
242 
243       if ((this._City != value))
244 
245         this._City = value;
246 
247     }
248 
249   }
250 
251   [Column(Storage = "_Region", DbType = "NVarChar(15)")]
252 
253   public string Region
254 
255   {
256 
257     get { return this._Region; }
258 
259     set
260 
261     {
262 
263       if ((this._Region != value))
264 
265         this._Region = value;
266 
267     }
268 
269   }
270 
271   [Column(Storage = "_PostalCode", DbType ="NVarChar(10)")]
272 
273    public string PostalCode
274 
275   {
276 
277     get { return this._PostalCode; }
278 
279     set
280 
281     {
282 
283        if ((this._PostalCode != value))
284 
285         this._PostalCode = value;
286 
287     }
288 
289   }
290 
291   [Column(Storage = "_Country", DbType ="NVarChar(15)")]
292 
293    public string Country
294 
295   {
296 
297     get { return this._Country; }
298 
299     set
300 
301     {
302 
303       if ((this._Country != value))
304 
305         this._Country = value;
306 
307     }
308 
309   }
310 
311   [Column(Storage = "_Phone", DbType ="NVarChar(24)")]
312 
313    public string Phone
314 
315   {
316 
317     get { return this._Phone; }
318 
319     set
320 
321     {
322 
323       if ((this._Phone != value))
324 
325         this._Phone = value;
326 
327     }
328 
329   }
330 
331   [Column(Storage = "_Fax", DbType ="NVarChar(24)")]
332 
333   public string Fax
334 
335   {
336 
337     get { return this._Fax; }
338 
339     set
340 
341     {
342 
343       if ((this._Fax != value))
344 
345         this._Fax = value;
346 
347     }
348 
349   }
350 
351 }
352 
353  
354 
355 PartialCustomersSetResult类 如下:
356 
357  
358 
359 public partial classPartialCustomersSetResult
360 
361 {
362 
363   private string _CustomerID;
364 
365   private string _ContactName;
366 
367   private string _CompanyName;
368 
369   public PartialCustomersSetResult()
370 
371   {
372 
373   }
374 
375   [Column (Storage = "_CustomerID", DbType ="NChar(5)")]
376 
377   public string CustomerID
378 
379   {
380 
381     get { return this._CustomerID; }
382 
383     set
384 
385     {
386 
387        if ((this._CustomerID != value))
388 
389         this._CustomerID = value;
390 
391     }
392 
393   }
394 
395   [Column(Storage = "_ContactName", DbType ="NVarChar(30)")]
396 
397   public string ContactName
398 
399   {
400 
401     get { return this._ContactName; }
402 
403     set
404 
405     {
406 
407        if ((this._ContactName != value))
408 
409          this._ContactName = value;
410 
411     }
412 
413   }
414 
415   [Column (Storage = "_CompanyName", DbType ="NVarChar(40) ")]
416 
417   public string CompanyName
418 
419   {
420 
421      get { return this._CompanyName; }
422 
423     set
424 
425     {
426 
427       if ((this._CompanyName != value))
428 
429          this._CompanyName = value;
430 
431     }
432 
433   }
434 
435 }
436 
437  
438 
439 这样就可以使用了,下面代码直接调用,分别返回各自的结果集合。
440 
441  
442 
443 //返回全部Customer结果集
444 
445 IMultipleResults result =db.Whole_Or_Partial_Customers_Set(1);
446 
447 IEnumerable<WholeCustomersSetResult>shape1 =
448 
449 result.GetResult<WholeCustomersSetResult>();
450 
451 foreach (WholeCustomersSetResult compNamein shape1)
452 
453 {
454 
455    Console.WriteLine(compName.CompanyName);
456 
457 }
458 
459 //返回部分 Customer结果集
460 
461 result =db.Whole_Or_Partial_Customers_Set(2);
462 
463 IEnumerable<PartialCustomersSetResult>shape2 =
464 
465 result.GetResult<PartialCustomersSetResult>();
466 
467 foreach (PartialCustomersSetResult con inshape2)
468 
469 {
470 
471    Console.WriteLine(con.ContactName);
472 
473 }
474 
475  
476 
477 语句描述:这个实例使用存储过程返回“WA”地区中的一组客户。返回的结果集形状取决于传入的参数。如果参数等于 1,则返回所有客户属性。如果参数等于2,则返回ContactName属性。
3.多个可能形状的单一结果集
  1 4.多个结果集
  2 
  3  
  4 
  5 这种存储过程可以生成多个结果形状,但我们已经知道结果的返回顺序。
  6 
  7  
  8 
  9 下面是一个按顺序返回多个结果集的存储过程Get Customer And Orders。 返回顾客ID为"SEVES"的顾客和他们所有的订单。
 10 
 11  
 12 
 13 ALTER PROCEDURE [dbo].[Get Customer AndOrders]
 14 
 15 (@CustomerID nchar(5))
 16 
 17   -- Add the parameters for the stored procedure here
 18 
 19 AS
 20 
 21 BEGIN
 22 
 23    -- SET NOCOUNT ON added to prevent extra result sets from
 24 
 25   -- interfering with SELECT statements.
 26 
 27   SET NOCOUNT ON;
 28 
 29    SELECT * FROM Customers AS c WHERE c.CustomerID = @CustomerID 
 30 
 31   SELECT * FROM Orders AS o WHERE o.CustomerID = @CustomerID
 32 
 33 END
 34 
 35  
 36 
 37 拖到设计器代码如下:
 38 
 39  
 40 
 41 [Function (Name="dbo.[Get Customer AndOrders]")]
 42 
 43 publicISingleResult<Get_Customer_And_OrdersResult>
 44 
 45 Get_Customer_And_Orders([Parameter(Name="CustomerID",
 46 
 47 DbType="NChar(5)")] stringcustomerID)
 48 
 49 {
 50 
 51    IExecuteResult result = this.ExecuteMethodCall(this,
 52 
 53    ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID);
 54 
 55    return ((ISingleResult<Get_Customer_And_OrdersResult>)
 56 
 57    (result.ReturnValue));
 58 
 59 }
 60 
 61  
 62 
 63 同样,我们要修改自动生成的代码:
 64 
 65  
 66 
 67 [Function(Name="dbo.[Get Customer AndOrders] ")]
 68 
 69 [ResultType(typeof(CustomerResultSet))]
 70 
 71 [ResultType(typeof(OrdersResultSet))]
 72 
 73 public IMultipleResultsGet_Customer_And_Orders
 74 
 75 ([Parameter(Name="CustomerID",DbType="NChar(5)")]
 76 
 77 string customerID)
 78 
 79 {
 80 
 81   IExecuteResult result = this.ExecuteMethodCall(this,
 82 
 83   ((MethodInfo) (MethodInfo.GetCurrentMethod())), customerID);
 84 
 85   return ((IMultipleResults)(result.ReturnValue));
 86 
 87 }
 88 
 89  
 90 
 91 同样,自己手写类,让其存储过程返回各自的结果集。
 92 
 93  
 94 
 95 CustomerResultSet类
 96 
 97  
 98 
 99 public partial class CustomerResultSet
100 
101 {
102 
103   private string _CustomerID;
104 
105   private string _CompanyName;
106 
107   private string _ContactName;
108 
109   private string _ContactTitle;
110 
111   private string _Address;
112 
113    private string _City;
114 
115   private string _Region;
116 
117    private string _PostalCode;
118 
119   private string _Country;
120 
121   private string _Phone;
122 
123   private string _Fax;
124 
125   public CustomerResultSet()
126 
127   {
128 
129   }
130 
131   [Column(Storage = "_CustomerID", DbType ="NChar(5)")]
132 
133    public string CustomerID
134 
135   {
136 
137     get { return this._CustomerID; }
138 
139     set
140 
141     {
142 
143        if ((this._CustomerID != value))
144 
145         this._CustomerID = value;
146 
147     }
148 
149   }
150 
151   [Column(Storage = "_CompanyName", DbType ="NVarChar(40)")]
152 
153   public string CompanyName
154 
155   {
156 
157     get { return this._CompanyName; }
158 
159     set
160 
161     {
162 
163        if ((this._CompanyName != value))
164 
165          this._CompanyName = value;
166 
167     }
168 
169   }
170 
171   [Column (Storage = "_ContactName", DbType ="NVarChar(30) ")]
172 
173   public string ContactName
174 
175   {
176 
177      get { return this._ContactName; }
178 
179     set
180 
181     {
182 
183       if ((this._ContactName != value))
184 
185          this._ContactName = value;
186 
187     }
188 
189   }
190 
191   [Column (Storage = "_ContactTitle", DbType ="NVarChar(30) ")]
192 
193   public string ContactTitle
194 
195   {
196 
197      get { return this._ContactTitle; }
198 
199     set
200 
201     {
202 
203       if ((this._ContactTitle != value))
204 
205          this._ContactTitle = value;
206 
207     }
208 
209   }
210 
211    [Column(Storage = "_Address", DbType = "NVarChar(60)")]
212 
213   public string Address
214 
215   {
216 
217     get { return this._Address; }
218 
219     set
220 
221     {
222 
223       if ((this._Address != value))
224 
225         this._Address = value;
226 
227     }
228 
229   }
230 
231   [Column(Storage = "_City", DbType ="NVarChar(15)")]
232 
233   public string City
234 
235   {
236 
237     get { return this._City; }
238 
239     set
240 
241     {
242 
243       if ((this._City != value))
244 
245         this._City = value;
246 
247     }
248 
249   }
250 
251   [Column(Storage = "_Region", DbType = "NVarChar(15)")]
252 
253   public string Region
254 
255   {
256 
257     get { return this._Region; }
258 
259     set
260 
261     {
262 
263       if ((this._Region != value))
264 
265         this._Region = value;
266 
267     }
268 
269   }
270 
271   [Column(Storage = "_PostalCode", DbType ="NVarChar(10)")]
272 
273    public string PostalCode
274 
275   {
276 
277     get { return this._PostalCode; }
278 
279     set
280 
281     {
282 
283        if ((this._PostalCode != value))
284 
285         this._PostalCode = value;
286 
287     }
288 
289   }
290 
291   [Column(Storage = "_Country", DbType ="NVarChar(15)")]
292 
293    public string Country
294 
295   {
296 
297     get { return this._Country; }
298 
299     set
300 
301     {
302 
303       if ((this._Country != value))
304 
305         this._Country = value;
306 
307     }
308 
309   }
310 
311   [Column(Storage = "_Phone", DbType ="NVarChar(24)")]
312 
313    public string Phone
314 
315   {
316 
317     get { return this._Phone; }
318 
319     set
320 
321     {
322 
323       if ((this._Phone != value))
324 
325         this._Phone = value;
326 
327     }
328 
329   }
330 
331   [Column(Storage = "_Fax", DbType ="NVarChar(24)")]
332 
333   public string Fax
334 
335   {
336 
337     get { return this._Fax; }
338 
339     set
340 
341     {
342 
343       if ((this._Fax != value))
344 
345         this._Fax = value;
346 
347     }
348 
349   }
350 
351 }
352 
353  
354 
355 OrdersResultSet 类
356 
357  
358 
359 public partial class OrdersResultSet
360 
361 {
362 
363   private System.Nullable<int> _OrderID;
364 
365   private string _CustomerID;
366 
367   private System.Nullable<int> _EmployeeID;
368 
369   private System.Nullable<System.DateTime> _OrderDate;
370 
371   private System.Nullable<System.DateTime> _RequiredDate;
372 
373   private System.Nullable<System.DateTime> _ShippedDate;
374 
375   private System.Nullable<int> _ShipVia;
376 
377   private System.Nullable<decimal> _Freight;
378 
379    private string _ShipName;
380 
381   private string _ShipAddress;
382 
383   private string _ShipCity;
384 
385   private string _ShipRegion;
386 
387   private string _ShipPostalCode;
388 
389   private string _ShipCountry;
390 
391   public OrdersResultSet()
392 
393   {
394 
395   }
396 
397   [Column(Storage = "_OrderID", DbType = "Int")]
398 
399   public System.Nullable<int> OrderID
400 
401   {
402 
403     get { return this._OrderID; }
404 
405     set
406 
407     {
408 
409       if ((this._OrderID != value))
410 
411         this._OrderID = value;
412 
413     }
414 
415   }
416 
417   [Column(Storage = "_CustomerID", DbType ="NChar(5)")]
418 
419   public string CustomerID
420 
421   {
422 
423     get { return this._CustomerID; }
424 
425     set
426 
427     {
428 
429       if ((this._CustomerID != value))
430 
431         this._CustomerID = value;
432 
433     }
434 
435   }
436 
437    [Column(Storage = "_EmployeeID", DbType ="Int")]
438 
439   public System.Nullable<int> EmployeeID
440 
441   {
442 
443     get { return this._EmployeeID; }
444 
445     set
446 
447     {
448 
449       if ((this._EmployeeID != value))
450 
451         this._EmployeeID = value;
452 
453     }
454 
455   }
456 
457    [Column(Storage = "_OrderDate", DbType ="DateTime")]
458 
459   public System.Nullable<System.DateTime> OrderDate
460 
461   {
462 
463     get { return this._OrderDate; }
464 
465     set
466 
467     {
468 
469       if ((this._OrderDate != value))
470 
471          this._OrderDate = value;
472 
473     }
474 
475   }
476 
477   [Column (Storage = "_RequiredDate", DbType ="DateTime")]
478 
479   public System.Nullable<System.DateTime> RequiredDate
480 
481   {
482 
483     get { return this._RequiredDate; }
484 
485     set
486 
487     {
488 
489       if ((this._RequiredDate != value))
490 
491          this._RequiredDate = value;
492 
493     }
494 
495   }
496 
497    [Column(Storage = "_ShippedDate", DbType ="DateTime")]
498 
499   public System.Nullable<System.DateTime> ShippedDate
500 
501   {
502 
503     get { return this._ShippedDate; }
504 
505     set
506 
507      {
508 
509       if ((this._ShippedDate != value))
510 
511         this._ShippedDate = value;
512 
513     }
514 
515   }
516 
517    [Column(Storage = "_ShipVia", DbType = "Int")]
518 
519   public System.Nullable<int> ShipVia
520 
521   {
522 
523     get { return this._ShipVia; }
524 
525     set
526 
527     {
528 
529       if ((this._ShipVia != value))
530 
531          this._ShipVia = value;
532 
533     }
534 
535   }
536 
537   [Column (Storage = "_Freight", DbType ="Money")]
538 
539   public System.Nullable<decimal> Freight
540 
541   {
542 
543     get { return this._Freight; }
544 
545     set
546 
547     {
548 
549       if ((this._Freight != value))
550 
551          this._Freight = value;
552 
553     }
554 
555   }
556 
557   [Column (Storage = "_ShipName", DbType ="NVarChar(40)")]
558 
559   public string ShipName
560 
561   {
562 
563     get { return this._ShipName; }
564 
565     set
566 
567     {
568 
569       if ((this._ShipName != value))
570 
571         this._ShipName = value;
572 
573     }
574 
575   }
576 
577   [Column(Storage = "_ShipAddress", DbType ="NVarChar(60)")]
578 
579   public string ShipAddress
580 
581   {
582 
583     get { return this._ShipAddress; }
584 
585     set
586 
587     {
588 
589        if ((this._ShipAddress != value))
590 
591          this._ShipAddress = value;
592 
593     }
594 
595   }
596 
597   [Column (Storage = "_ShipCity", DbType ="NVarChar(15)")]
598 
599   public string ShipCity
600 
601   {
602 
603     get { return this._ShipCity; }
604 
605     set
606 
607     {
608 
609       if ((this._ShipCity != value))
610 
611         this._ShipCity = value;
612 
613     }
614 
615   }
616 
617   [Column(Storage = "_ShipRegion", DbType ="NVarChar(15)")]
618 
619    public string ShipRegion
620 
621   {
622 
623     get { return this._ShipRegion; }
624 
625     set
626 
627     {
628 
629        if ((this._ShipRegion != value))
630 
631         this._ShipRegion = value;
632 
633     }
634 
635   }
636 
637   [Column(Storage = "_ShipPostalCode", DbType ="NVarChar(10)")]
638 
639   public string ShipPostalCode
640 
641   {
642 
643     get { return this._ShipPostalCode; }
644 
645     set
646 
647     {
648 
649       if ((this._ShipPostalCode != value))
650 
651          this._ShipPostalCode = value;
652 
653     }
654 
655   }
656 
657    [Column(Storage = "_ShipCountry", DbType = "NVarChar(15)")]
658 
659   public string ShipCountry
660 
661   {
662 
663     get { return this._ShipCountry; }
664 
665     set
666 
667     {
668 
669       if ((this._ShipCountry != value))
670 
671          this._ShipCountry = value;
672 
673     }
674 
675   }
676 
677 }
678 
679  
680 
681  
682 
683 这时,只要调用就可以了。
684 
685  
686 
687 IMultipleResults result =db.Get_Customer_And_Orders("SEVES");
688 
689 //返回 Customer结果集
690 
691 IEnumerable<CustomerResultSet>customer =
692 
693 result.GetResult<CustomerResultSet>();
694 
695 //返回Orders结果集
696 
697 IEnumerable<OrdersResultSet> orders =
698 
699 result.GetResult<OrdersResultSet>();
700 
701 //在这里,我们读取CustomerResultSet中的数据
702 
703 foreach (CustomerResultSet cust incustomer)
704 
705 {
706 
707   Console.WriteLine(cust.CustomerID);
708 
709 }
710 
711  
712 
713 语句描述:这个实例使用存储过程返回客户“SEVES”及其所有订单。
4.多个结果集
 1 5.带输出参数
 2 
 3  
 4 
 5 LINQ to SQL 将输出参数映射到引用参数 ,并且对于值类型,它将参数声明为可以为null。
 6 
 7  
 8 
 9 下面的示例带有单个输入参数(客户 ID)并返回一个输出参数(该客户的总销售额)。
10 
11  
12 
13 ALTER PROCEDURE [dbo].[CustOrderTotal]
14 
15 @CustomerID nchar(5),
16 
17 @TotalSales money OUTPUT
18 
19 AS
20 
21 SELECT @TotalSales =SUM(OD.UNITPRICE*(1-OD.DISCOUNT) * OD.QUANTITY)
22 
23 FROM ORDERS O, "ORDER DETAILS" OD
24 
25 where O.CUSTOMERID = @CustomerID AND O.ORDERID= OD.ORDERID
26 
27  
28 
29 把这个存储过程拖到设计器中,图片如下:
30 
31  
32 
33  
34 
35 其生成代码如下:
36 
37  
38 
39 [Function(Name="dbo.CustOrderTotal")]
40 
41 public int CustOrderTotal (
42 
43 [Parameter(Name="CustomerID",DbType="NChar(5) ")]string customerID,
44 
45 [Parameter (Name="TotalSales",DbType="Money")]
46 
47  ref System.Nullable<decimal> totalSales)
48 
49 {
50 
51    IExecuteResult result = this.ExecuteMethodCall(this,
52 
53    ((MethodInfo)(MethodInfo.GetCurrentMethod())),
54 
55   customerID, totalSales);
56 
57   totalSales = ((System.Nullable<decimal>)
58 
59   (result.GetParameterValue(1)));
60 
61   return ((int) (result.ReturnValue));
62 
63 }
64 
65  
66 
67 我们使用下面的语句调用此存储过程:注意:输出参数是按引用传递的,以支持参数为“in/out”的方案。在这种情况下,参数仅为“out”。
68 
69  
70 
71 decimal? totalSales = 0;
72 
73 string customerID = "ALFKI";
74 
75 db.CustOrderTotal(customerID, reftotalSales);
76 
77 Console.WriteLine("Total Sales forCustomer '{0}' = {1:C}",
78 
79 customerID, totalSales);
80 
81  
82 
83 语句描述:这个实例使用返回 Out 参数的存储过程。
84 
85  
86 
87 好了,就说到这里了,其增删改操作同理。相信大家通过这5个实例理解了存储过程。
5.带输出参数

LINQ to SQL语句(21)之用户定义函数

我们可以在LINQ to SQL中使用用户定义函数。只要把用户定义函数拖到O/R设计器中,LINQ to SQL自动使用FunctionAttribute属性和ParameterAttribute属性(如果需要)将其函数指定为方法。这时,我们只需简单调用即可。

 

在这里注意:使用用户定义函数的时候必须满足以下形式之一,否则会出现InvalidOperationException异常情况。

 

具有正确映射属性的方法调用的函数。这里使用FunctionAttribute属性和 ParameterAttribute属性。

 

特定于LINQ to SQL的静态SQL方法。

 

.NET Framework方法支持的函数。

 

下面介绍几个例子:

 1 1.在Select中使用用户定义的标量函数
 2 
 3  
 4 
 5 所谓标量函数是指返回在 RETURNS 子句中定义的类型的单个数据值。可以使用所有标量数据类型,包括 bigint 和 sql_variant。不支持 timestamp 数据类型、用户定义数据类型和非标量类型(如 table 或 cursor)。在 BEGIN...END 块中定义的函数主体包含返回该值的 Transact-SQL 语句系列。返回类型可以是除 text、ntext、image 、cursor 和 timestamp 之外的任何数据类型。我们在系统自带的 NORTHWND.MDF数据库中,有3个自定义函数,这里使用 TotalProductUnitPriceByCategory,其代码如下:
 6 
 7  
 8 
 9 ALTER FUNCTION[dbo].[TotalProductUnitPriceByCategory]
10 
11 (@categoryID int)
12 
13 RETURNS Money
14 
15 AS
16 
17 BEGIN
18 
19   -- Declare the return variable here
20 
21   DECLARE @ResultVar Money
22 
23   -- Add the T-SQL statements to compute the return value here
24 
25   SELECT @ResultVar = (Select SUM(UnitPrice)
26 
27             from Products
28 
29             where CategoryID = @categoryID)
30 
31   -- Return the result of the function
32 
33   RETURN @ResultVar
34 
35 END
36 
37  
38 
39 我们将其拖到设计器中,LINQ to SQL通过使用 FunctionAttribute 属性将类中定义的客户端方法映射到用户定义的函数。请注意,这个方法体会构造一个捕获方法调用意向的表达式,并将该表达式传递给 DataContext 进行转换和执行。
40 
41  
42 
43 [Function(Name="dbo.TotalProductUnitPriceByCategory",
44 
45 IsComposable=true)]
46 
47 public System.Nullable<decimal>TotalProductUnitPriceByCategory(
48 
49 [Parameter (DbType="Int")]System.Nullable<int> categoryID)
50 
51 {
52 
53   return ((System.Nullable<decimal>)(this.ExecuteMethodCall(this,
54 
55   ((MethodInfo) (MethodInfo.GetCurrentMethod())), categoryID)
56 
57    .ReturnValue));
58 
59 }
60 
61  
62 
63 我们使用时,可以用以下代码来调用:
64 
65  
66 
67 var q = from c in db.Categories
68 
69     select new
70 
71     {
72 
73       c.CategoryID,
74 
75        TotalUnitPrice =
76 
77          db.TotalProductUnitPriceByCategory(c.CategoryID)
78 
79     };
80 
81  
82 
83 这时,LINQ to SQL自动生成SQL语句如下:
84 
85  
86 
87 SELECT [t0].[CategoryID],CONVERT(Decimal(29,4),
88 
89 [dbo].[TotalProductUnitPriceByCategory]([t0].[CategoryID]))
90 
91 AS [TotalUnitPrice] FROM [dbo].[Categories]AS [t0]
1.在Select中使用用户定义的标量函数
 1 2.在Where从句中 使用用户定义的标量函数
 2 
 3 这个例子使用方法同上一个例子原理基本相同了,MinUnitPriceByCategory自定义函数如下:
 4 
 5  
 6 
 7 ALTER FUNCTION[dbo].[MinUnitPriceByCategory]
 8 
 9 (@categoryID INT
10 
11 )
12 
13 RETURNS Money
14 
15 AS
16 
17 BEGIN
18 
19   -- Declare the return variable here
20 
21   DECLARE @ResultVar Money
22 
23   -- Add the T -SQL statements to compute the return value here
24 
25   SELECT @ResultVar = MIN(p.UnitPrice) FROM Products as p
26 
27   WHERE p.CategoryID = @categoryID
28 
29   -- Return the result of the function
30 
31   RETURN @ResultVar
32 
33 END
34 
35  
36 
37 拖到设计器中,生成代码如下:
38 
39  
40 
41 [Function (Name="dbo.MinUnitPriceByCategory",IsComposable=true)]
42 
43 public System.Nullable<decimal>MinUnitPriceByCategory(
44 
45 [Parameter(DbType="Int")]System.Nullable<int> categoryID)
46 
47 {
48 
49   return ((System.Nullable<decimal>) (this.ExecuteMethodCall(
50 
51   this, ((MethodInfo) (MethodInfo.GetCurrentMethod())),
52 
53    categoryID).ReturnValue));
54 
55 }
56 
57  
58 
59 这时可以使用了:注意这里在 LINQ to SQL 查询中,对生成的用户定义函数方法 MinUnitPriceByCategory的内联调用。此函数不会立即执行,这是因为查询会延 迟执行。延迟执行的查询中包含的函数直到此查询执行时才会执行。为此查询生成的 SQL 会转换成对数据库中用户定义函数的调用(请参见此查询后面的生成的 SQL语句),当在查询外部调用这个函数时,LINQ to SQL 会用方法调用表达式创建一个简单查询并执行。 
60 
61  
62 
63 var q =
64 
65   from p in db.Products
66 
67   where p.UnitPrice ==
68 
69    db.MinUnitPriceByCategory(p.CategoryID)
70 
71   select p;
72 
73  
74 
75 它自动生成的SQL语句如下:
76 
77  
78 
79 SELECT [t0]. [ProductID],[t0].[ProductName], [t0].[SupplierID],
80 
81 [t0]. [CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice],
82 
83 [t0]. [UnitsInStock],[t0].[UnitsOnOrder],[t0].[ReorderLevel],
84 
85 [t0]. [Discontinued]FROM [dbo].[Products]AS [t0]
86 
87 WHERE [t0]. [UnitPrice] =
88 
89 [dbo].[MinUnitPriceByCategory]([t0].[CategoryID])
2.在Where从句中 使用用户定义的标量函数
  1 3.使用用户定义的表值函数
  2 
  3  
  4 
  5 表值函数返回单个行集(与存储过程不同,存储过程可返回多个结果形状)。由于表值函数的返回类型为 Table,因此在 SQL 中可以使用表的任何地方均可以使用表值函数。此外,您还可以完全像处理表那样来处理表值函数。
  6 
  7  
  8 
  9 下面的 SQL 用户定义函数显式声明其返回一个 TABLE。因此,隐式定义了所返回的行集结构。
 10 
 11 ALTER FUNCTION[dbo].[ProductsUnderThisUnitPrice]
 12 
 13 (@price Money
 14 
 15 )
 16 
 17 RETURNS TABLE
 18 
 19 AS
 20 
 21 RETURN
 22 
 23   SELECT *
 24 
 25    FROM Products as P
 26 
 27   Where p.UnitPrice < @price
 28 
 29  
 30 
 31 拖到设计器中,LINQ to SQL 按如下方式映射此函数:
 32 
 33  
 34 
 35 [Function(Name="dbo.ProductsUnderThisUnitPrice",
 36 
 37 IsComposable=true)]
 38 
 39 publicIQueryable<ProductsUnderThisUnitPriceResult>
 40 
 41 ProductsUnderThisUnitPrice([Parameter(DbType="Money")]
 42 
 43 System.Nullable<decimal> price)
 44 
 45 {
 46 
 47   return this.CreateMethodCallQuery
 48 
 49    <ProductsUnderThisUnitPriceResult>(this,
 50 
 51   ((MethodInfo) (MethodInfo.GetCurrentMethod())), price);
 52 
 53 }
 54 
 55  
 56 
 57 这时我们小小的修改一下Discontinued属性为可空的bool类型。
 58 
 59  
 60 
 61 private System.Nullable<bool>_Discontinued;
 62 
 63 public System.Nullable<bool>Discontinued
 64 
 65 {
 66 
 67 }
 68 
 69  
 70 
 71 我们可以这样调用使用了:
 72 
 73  
 74 
 75 var q = from p indb.ProductsUnderThisUnitPrice(10.25M)
 76 
 77     where ! (p.Discontinued ?? false)
 78 
 79     select p;
 80 
 81  
 82 
 83 其生成 SQL语句如下:
 84 
 85  
 86 
 87 SELECT [t0].[ProductID],[t0].[ProductName], [t0].[SupplierID],
 88 
 89 [t0].[CategoryID], [t0].[QuantityPerUnit],[t0].[UnitPrice],
 90 
 91 [t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0].[ReorderLevel],
 92 
 93 [t0].[Discontinued]
 94 
 95 FROM [dbo].[ProductsUnderThisUnitPrice](@p0) AS [t0]
 96 
 97 WHERE NOT ((COALESCE([t0].[Discontinued],@p1)) = 1)
 98 
 99 -- @p0: Input Money (Size = 0; Prec = 19;Scale = 4) [10.25]
100 
101 -- @p1: Input Int (Size = 0; Prec = 0;Scale = 0) [0]
3.使用用户定义的表值函数
 1 4.以联接方式使用用户定义的表值函数
 2 
 3  
 4 
 5 我们利用上面的ProductsUnderThisUnitPrice用户定义函数,在 LINQ to SQL 中, 调用如下:
 6 
 7  
 8 
 9 var q =
10 
11   from c in db.Categories
12 
13   join p in db.ProductsUnderThisUnitPrice(8.50M) on
14 
15    c.CategoryID equals p.CategoryID into prods
16 
17   from p in prods
18 
19   select new
20 
21   {
22 
23     c.CategoryID,
24 
25     c.CategoryName,
26 
27     p.ProductName,
28 
29      p.UnitPrice
30 
31   };
32 
33  
34 
35 其生成的 SQL 代码说明对此函数返回的表执行联接。
36 
37  
38 
39 SELECT [t0].[CategoryID], [t0]. [CategoryName],
40 
41 [t1].[ProductName], [t1].[UnitPrice]
42 
43 FROM [dbo].[Categories] AS [t0]
44 
45 CROSS JOIN [dbo].[ProductsUnderThisUnitPrice](@p0) AS [t1]
46 
47 WHERE ([t0]. [CategoryID]) =[t1].[CategoryID]
48 
49 -- @p0: Input Money (Size = 0; Prec = 19;Scale = 4) [8.50]
4.以联接方式使用用户定义的表值函数

LINQ to SQL语句(22)之DataContext

DataContext

 

DataContext作为LINQ to SQL框架的主入口点,为我们 提供了一些方法和属性,本文用几个例子说明DataContext几个典型的应用。

  1 创建和删除数据库
  2 
  3  
  4 
  5 CreateDatabase方法用于在服务器上创建数据库。
  6 
  7  
  8 
  9 DeleteDatabase方法用于删除由DataContext连接字符串标识的数据 库。
 10 
 11  
 12 
 13 数据库的名称有以下方法来定义:
 14 
 15  
 16 
 17 如果数据库在连接字符串中标识,则使用该连接字符串的名称。
 18 
 19  
 20 
 21 如果存在DatabaseAttribute属性 (Attribute),则将其Name属性(Property)用作数据库的名称。
 22 
 23  
 24 
 25 如果连接字符串中没有数据库标记,并且使用强类型的DataContext,则会检查与 DataContext继承类名称相同的数据库。如果使用弱类型的DataContext,则会引发异常。
 26 
 27  
 28 
 29 如果已通过使用文件名创建了DataContext,则会创建与该文件名相对应的数据库。
 30 
 31  
 32 
 33 我们首先用实体类描述关系数据库表和列的结构的属性。再调用DataContext的CreateDatabase方法,LINQ to SQL会用我们的定义的实体类结构来构造一个新的数据库实例。还可以通过使用 .mdf 文件或只使用目录名(取决于连接字符串),将 CreateDatabase与SQL Server一起使用。 LINQ to SQL使用连接字符串来定义要创建的数据库和作为数据库创建位置的服务器。
 34 
 35  
 36 
 37 说了这么多,用一段实例说明一下吧!
 38 
 39  
 40 
 41 首先,我们新建一个NewCreateDB类用于创建一个名为NewCreateDB.mdf的新数据库,该数据库有一个Person表,有三个字段,分别为PersonID、PersonName、Age。
 42 
 43  
 44 
 45 public class NewCreateDB : DataContext
 46 
 47 {
 48 
 49   public Table<Person> Persons;
 50 
 51   public NewCreateDB (string connection)
 52 
 53     :
 54 
 55     base(connection)
 56 
 57   {
 58 
 59   }
 60 
 61   public NewCreateDB(System.Data.IDbConnection connection)
 62 
 63     :
 64 
 65     base(connection)
 66 
 67   {
 68 
 69   }
 70 
 71 }
 72 
 73 [Table(Name = "Person")]
 74 
 75 public partial class Person :INotifyPropertyChanged
 76 
 77 {
 78 
 79   private int _PersonID;
 80 
 81   private string _PersonName;
 82 
 83   private System.Nullable<int> _Age;
 84 
 85   public Person() { }
 86 
 87   [Column(Storage = "_PersonID", DbType = "INT",
 88 
 89     IsPrimaryKey = true)]
 90 
 91   public int PersonID
 92 
 93   {
 94 
 95     get { return this._PersonID; }
 96 
 97     set
 98 
 99     {
100 
101       if ((this._PersonID != value))
102 
103       {
104 
105          this.OnPropertyChanged("PersonID");
106 
107          this._PersonID = value;
108 
109         this.OnPropertyChanged ("PersonID");
110 
111       }
112 
113     }
114 
115   }
116 
117   [Column(Storage = "_PersonName", DbType ="NVarChar(30)")]
118 
119   public string PersonName
120 
121    {
122 
123     get { return this._PersonName; }
124 
125     set
126 
127     {
128 
129       if ((this._PersonName != value))
130 
131       {
132 
133         this.OnPropertyChanged ("PersonName");
134 
135         this._PersonName = value;
136 
137         this.OnPropertyChanged ("PersonName");
138 
139       }
140 
141     }
142 
143   }
144 
145   [Column(Storage = "_Age", DbType = "INT")]
146 
147   public System.Nullable<int> Age
148 
149   {
150 
151     get { return this._Age; }
152 
153     set
154 
155     {
156 
157       if ((this._Age != value))
158 
159        {
160 
161         this.OnPropertyChanged("Age");
162 
163         this._Age = value;
164 
165          this.OnPropertyChanged("Age");
166 
167       }
168 
169     }
170 
171   }
172 
173   public event PropertyChangedEventHandler PropertyChanged;
174 
175   protected virtual void OnPropertyChanged (string PropertyName)
176 
177   {
178 
179     if ((this.PropertyChanged != null))
180 
181     {
182 
183        this.PropertyChanged(this,
184 
185         new PropertyChangedEventArgs(PropertyName));
186 
187     }
188 
189   }
190 
191 }
192 
193  
194 
195 接下来的一段代码先创建一个数据库,在调用 CreateDatabase后,新的数据库就会存在并且会接受一般的查询和命令。接着插入一条记录并且查询。最后删除这个数据库。
196 
197  
198 
199 //1.新建一个临时 文件夹来存放新建的数据库
200 
201 string userTempFolder =Environment.GetEnvironmentVariable
202 
203 ("SystemDrive") +@"YJingLee";
204 
205 Directory.CreateDirectory (userTempFolder);
206 
207 //2.新建数据库NewCreateDB
208 
209 string userMDF = System.IO.Path.Combine(userTempFolder,
210 
211   @"NewCreateDB.mdf");
212 
213 string connStr = String.Format (@"DataSource=.SQLEXPRESS;
214 
215 AttachDbFilename={0};IntegratedSecurity=True;
216 
217 Connect Timeout=30;User Instance=True;
218 
219 Integrated Security = SSPI;",userMDF);
220 
221 NewCreateDB newDB = newNewCreateDB(connStr);
222 
223 newDB.CreateDatabase();
224 
225 //3.插入 数据并查询
226 
227 var newRow = new Person
228 
229 {
230 
231    PersonID = 1,
232 
233    PersonName = "YJingLee",
234 
235    Age = 22
236 
237 };
238 
239 newDB.Persons.InsertOnSubmit(newRow);
240 
241 newDB.SubmitChanges();
242 
243 var q = from x in newDB.Persons
244 
245      select x;
246 
247 //4.删除数据库
248 
249 newDB.DeleteDatabase();
250 
251 //5.删除临时目录
252 
253 Directory.Delete (userTempFolder);
创建和删除数据库
 1 数据库验证
 2 
 3  
 4 
 5 DatabaseExists方法用于 尝试通过使用DataContext中的连接打开数据库,如果成功返回true。
 6 
 7  
 8 
 9 下面代码说明是否存在Northwind数据库和NewCreateDB数据库。
10 
11  
12 
13 // 检测Northwind数据库是否存在
14 
15 if (db.DatabaseExists())
16 
17    Console.WriteLine("Northwind数据库存在");
18 
19 else
20 
21   Console.WriteLine("Northwind数据库不存在");
22 
23 //检测 NewCreateDB数据库是否存在
24 
25 string userTempFolder =Environment.GetEnvironmentVariable("Temp");
26 
27 string userMDF =System.IO.Path.Combine(userTempFolder,
28 
29 @"NewCreateDB.mdf");
30 
31 NewCreateDB newDB = newNewCreateDB(userMDF);
32 
33 if (newDB.DatabaseExists())
34 
35    Console.WriteLine("NewCreateDB数据库存在");
36 
37 else
38 
39   Console.WriteLine("NewCreateDB数据库不存在 ");
数据库验证
 1 数据库更改
 2 
 3  
 4 
 5 SubmitChanges方法计算要插入、更 新或删除的已修改对象的集,并执行相应命令以实现对数据库的更改。
 6 
 7  
 8 
 9 无论对象做了多少项更改,都只是在更改内存中的副本。并未对数据库中的实际数据做任何更改。直到对DataContext显式调用SubmitChanges,所做的更改才会传输到服务器。调用时,DataContext会设法将我们所做的更改转换为等效的SQL 命令。我们也可以使用自己的自定义逻辑来重写这些操作,但提交顺序是由 DataContext的一项称作“更改处理器”的服务来协调的。事件的顺序如下:
10 
11  
12 
13 当调用SubmitChanges时,LINQ to SQL会检查已知对象的集合以确定新实例是否已附加到它们。如果已附加,这些新实例将添加到被跟踪对象的集合。
14 
15  
16 
17 所有具有挂起更改的对象将按照它们之间的依赖关系排序成一个对象序列。如果一个对象的更改依赖于其他对象,则这个对象将排在其依赖项之后。
18 
19  
20 
21 在即将传输任何实际更改时,LINQ to SQL会启动一个事务来封装由各条命令组成的系列。
22 
23  
24 
25 对对象的更改会逐个转换为SQL命令,然后发送到服务器。
26 
27  
28 
29 如果数据库检测到任何错误,都会造成提交进程停止并引发异常。将回滚对数据库的所有更改,就像未进行过提交一样。DataContext 仍具有所有更改的完整记录。
30 
31  
32 
33 下面代码说明的是在数据库中查询CustomerID 为ALFKI的顾客,然后修改其公司名称,第一次更新并调用SubmitChanges()方法,第二次更新了数据但并未调用SubmitChanges()方法。
34 
35 //查询
36 
37 Customer cust = db.Customers.First(c =>c.CustomerID == "ALFKI");
38 
39 //更新数据并调用SubmitChanges()方法
40 
41 cust.CompanyName = "YJingLee'sBlog";
42 
43 db.SubmitChanges();
44 
45 //更新数据没有调用SubmitChanges()方法
46 
47 cust.CompanyName ="http://lyj.cnblogs.com";
数据库更改
 1 动态查询
 2 
 3  
 4 
 5 使用动态查询,这个例子用CreateQuery()方法创建一个 IQueryable<T>类型表达式输出查询的语句。这里给个例子说明一下。有关动态查询具体内容,下一篇介绍。
 6 
 7  
 8 
 9 var c1 =Expression.Parameter(typeof(Customer), "c");
10 
11 PropertyInfo City =typeof(Customer).GetProperty ("City");
12 
13 var pred =Expression.Lambda<Func<Customer, bool>>(
14 
15    Expression.Equal(
16 
17   Expression.Property(c1, City),
18 
19    Expression.Constant("Seattle")
20 
21   ), c1
22 
23 );
24 
25 IQueryable custs = db.Customers;
26 
27 Expression expr =Expression.Call(typeof(Queryable), "Where",
28 
29   new Type[] { custs.ElementType }, custs.Expression, pred);
30 
31 IQueryable<Customer> q =db.Customers.AsQueryable().
32 
33 Provider.CreateQuery<Customer>(expr);
动态查询
 1 日志
 2 
 3  
 4 
 5 Log属性用于将SQL查询或命令打印到TextReader。此方法对了解 LINQto SQL 功能和调试特定的问题可能很有用。
 6 
 7  
 8 
 9 下面的示例使用Log属性在 SQL代码执行前在控制台窗口中显示此代码。我们可以将此属性与查询、插入、更新和删除命令一起使用。
10 
11  
12 
13 //关闭日志功能
14 
15 //db.Log = null;
16 
17 //使用日志功能:日志输出到控制台窗口
18 
19 db.Log = Console.Out;
20 
21 var q = from c in db.Customers
22 
23     where c.City == "London"
24 
25     select c;
26 
27 //日志输出到 文件
28 
29 StreamWriter sw = newStreamWriter(Server.MapPath ("log.txt"), true);
30 
31 db.Log = sw;
32 
33 var q = from c in db.Customers
34 
35     where c.City == "London"
36 
37     select c;
38 
39 sw.Close();
日志

LINQ to SQL语句(23)之动态查询

有这样一个场景:应用程序可能会提供一个用户界面,用户可以使用该用户界面指定一个或多个谓词来筛选数据。这种情况在编译时不知道查询的细节,动态查询将十分有用。

 

在LINQ中,Lambda表达式是许多标准查询运算符的基础,编译器创建lambda表达式以捕获基础查询方法(例如 Where、Select、Order By、Take While 以及其他方法)中定义的计算。表达式目录树用于针对数据源的结构化查询,这些数据源实现IQueryable<T>。例如,LINQ to SQL 提供程序实现 IQueryable<T>接口,用于查询关系数据存储。C#和Visual Basic编译器会针对此类数据源的查询编译为代码,该代码在运行时将生成一个表达式目录树。然后,查询提供程序可以遍历表达式目录树数据结构,并将其转换为适合于数据源的查询语言。

 

表达式目录树在 LINQ中用于表示分配给类型为Expression<TDelegate>的变量的Lambda表 达式。还可用于创建动态LINQ查询。

 

System.Linq.Expressions命名空间 提供用于手动生成表达式目录树的API。Expression类包含创建特定类型的表达 式目录树节点的静态工厂方法,例如,ParameterExpression(表示一个已命名的参数表达式)或 MethodCallExpression(表示一个方法调用)。编译器生成的表达式目录树的根始终在类型Expression<TDelegate>的节点中,其中 TDelegate是包含至多五个输入参数的任何TDelegate委托;也就是说,其根节点是表示一个lambda表达式。

 

下面几个例子描述如何使用表达式目录树来创建动态LINQ查询。

 1 1.Select
 2 
 3  
 4 
 5 下面例子说明如何使用表达式树依据 IQueryable 数据源构造一个动态查询,查询出每个顾客的ContactName,并用GetCommand方法获取其生成SQL语句。
 6 
 7  
 8 
 9 //依据IQueryable数据 源构造一个查询
10 
11 IQueryable<Customer> custs =db.Customers;
12 
13 //组建一个表达式树来创建一个参数
14 
15 ParameterExpression param =
16 
17   Expression.Parameter(typeof (Customer), "c");
18 
19 //组建表达式树:c.ContactName
20 
21 Expression selector =Expression.Property(param,
22 
23   typeof (Customer).GetProperty("ContactName"));
24 
25 Expression pred =Expression.Lambda(selector, param);
26 
27 //组建表达式树:Select(c=>c.ContactName)
28 
29 Expression expr = Expression.Call(typeof(Queryable), "Select",
30 
31   new Type[] { typeof (Customer), typeof(string) },
32 
33   Expression.Constant(custs), pred);
34 
35 //使用表达式树来生成动态查询
36 
37 IQueryable<string> query =db.Customers.AsQueryable()
38 
39   .Provider.CreateQuery<string>(expr);
40 
41 //使用GetCommand方法 获取SQL语句
42 
43 System.Data.Common.DbCommand cmd =db.GetCommand (query);
44 
45 Console.WriteLine(cmd.CommandText);
46 
47  
48 
49 生成的 SQL语句为:
50 
51  
52 
53 SELECT [t0].[ContactName] FROM [dbo]. [Customers]AS [t0]
1.Select
  1 2.Where
  2 
  3  
  4 
  5 下面一个例子是“搭建”Where用法来动态查询城市在伦敦的顾客。
  6 
  7  
  8 
  9 IQueryable<Customer> custs =db.Customers;
 10 
 11 // 创建一个参数c
 12 
 13 ParameterExpression param =
 14 
 15    Expression.Parameter(typeof(Customer), "c");
 16 
 17 //c.City=="London"
 18 
 19 Expression left = Expression.Property(param,
 20 
 21   typeof(Customer).GetProperty ("City"));
 22 
 23 Expression right = Expression.Constant("London");
 24 
 25 Expression filter = Expression.Equal(left,right);
 26 
 27 Expression pred = Expression.Lambda(filter,param);
 28 
 29 //Where(c=>c.City=="London")
 30 
 31 Expression expr = Expression.Call(typeof(Queryable),"Where",
 32 
 33   new Type[] { typeof(Customer) },
 34 
 35   Expression.Constant(custs), pred);
 36 
 37 //生成动态查询
 38 
 39 IQueryable<Customer> query =db.Customers.AsQueryable()
 40 
 41   .Provider.CreateQuery<Customer>(expr);
 42 
 43  
 44 
 45 生成的SQL 语句为:
 46 
 47  
 48 
 49 SELECT [t0].[CustomerID],[t0].[CompanyName], [t0].[ContactName],
 50 
 51 [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region],
 52 
 53 [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax]
 54 
 55 FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] = @p0
 56 
 57 -- @p0: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
 58 
 59  
 60 
 61 3.OrderBy本例既实现排序功能又实现了过滤功能。
 62 
 63  
 64 
 65 IQueryable<Customer> custs =db.Customers;
 66 
 67 //创建一个 参数c
 68 
 69 ParameterExpression param =
 70 
 71   Expression.Parameter (typeof(Customer), "c");
 72 
 73 //c.City=="London"
 74 
 75 Expression left = Expression.Property(param,
 76 
 77    typeof(Customer).GetProperty ("City"));
 78 
 79 Expression right = Expression.Constant("London");
 80 
 81 Expression filter = Expression.Equal(left,right);
 82 
 83 Expression pred = Expression.Lambda(filter,param);
 84 
 85 //Where(c=>c.City=="London")
 86 
 87 MethodCallExpression whereCallExpression =Expression.Call(
 88 
 89    typeof(Queryable), "Where",
 90 
 91    new Type[] { typeof(Customer) },
 92 
 93    Expression.Constant(custs), pred);
 94 
 95 //OrderBy(ContactName => ContactName)
 96 
 97 MethodCallExpression orderByCallExpression= Expression.Call(
 98 
 99    typeof(Queryable), "OrderBy",
100 
101    new Type[] { typeof(Customer), typeof(string) },
102 
103    whereCallExpression,
104 
105    Expression.Lambda(Expression.Property
106 
107    (param, "ContactName"), param));
108 
109 //生成动态查询
110 
111 IQueryable<Customer> query =db.Customers.AsQueryable()
112 
113    .Provider.CreateQuery<Customer> (orderByCallExpression);
114 
115  
116 
117 下面一张截图显示了怎么动态生成动态查询的过程
118 
119  
120 
121 生成的SQL语句为:
122 
123  
124 
125 SELECT [t0].[CustomerID],[t0].[CompanyName], [t0].[ContactName],
126 
127 [t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region],
128 
129 [t0].[PostalCode], [t0].[Country], [t0].[Phone],[t0].[Fax]
130 
131 FROM [dbo].[Customers] AS [t0] WHERE[t0].[City] = @p0
132 
133 ORDER BY [t0].[ContactName]
134 
135 -- @p0: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
136 
137 4.Union
138 
139  
140 
141 下面的例子使用表达式树动态查询顾客和雇员同在的城市。
142 
143  
144 
145 //e.City
146 
147 IQueryable<Customer> custs = db.Customers;     
148 
149 ParameterExpression param1 =
150 
151 Expression.Parameter(typeof(Customer),"e");
152 
153 Expression left1 =Expression.Property(param1,
154 
155   typeof (Customer).GetProperty("City"));
156 
157 Expression pred1 = Expression.Lambda(left1,param1);
158 
159 //c.City
160 
161 IQueryable<Employee> employees =db.Employees;
162 
163 ParameterExpression param2 =
164 
165 Expression.Parameter(typeof (Employee),"c");
166 
167 Expression left2 =Expression.Property(param2,
168 
169   typeof(Employee).GetProperty ("City"));
170 
171 Expression pred2 = Expression.Lambda(left2,param2);
172 
173 //Select(e=>e.City)
174 
175 Expression expr1 =Expression.Call(typeof(Queryable), "Select",
176 
177   new Type[] { typeof(Customer), typeof(string) },
178 
179    Expression.Constant(custs), pred1);
180 
181 //Select(c=>c.City)
182 
183 Expression expr2 =Expression.Call(typeof(Queryable), "Select",
184 
185   new Type[] { typeof(Employee), typeof (string) },
186 
187   Expression.Constant(employees), pred2);
188 
189 //生 成动态查询
190 
191 IQueryable<string> q1 =db.Customers.AsQueryable()
192 
193   .Provider.CreateQuery<string>(expr1);
194 
195 IQueryable<string> q2 =db.Employees.AsQueryable()
196 
197   .Provider.CreateQuery<string>(expr2);
198 
199 //并集
200 
201 var q3 = q1.Union(q2);
202 
203  
204 
205 生成的SQL语句为:
206 
207  
208 
209 SELECT [t2].[City]
210 
211 FROM (
212 
213   SELECT [t0].[City] FROM [dbo]. [Customers] AS [t0]
214 
215   UNION
216 
217   SELECT [t1].[City] FROM [dbo].[Employees] AS [t1]
218 
219   ) AS [t2]
2.Where

LINQ to SQL语句(24)之视图

视图

 

我们使用视图和使用数据表类似,只需将视图从“服务器资源管理器/数据库资源管理器”拖动到O/R 设计器上,自动可以创建基于这些视图的实体类。我们可以同操作数据表一样来操作视图了。这里注意:O/R 设计器是一个简单的对象关系映射器,因为它仅支持 1:1 映射关系。换句话说,实体类与数据库表或视图之间只能具有 1:1 映射关系。不支持复杂映射(例如,将一个实体类映射到多个表)。但是,可以将一个实体类映射到一个联接多个相关表的视图。 下面使用NORTHWND数据库中自带的Invoices、QuarterlyOrders 两个视图为例,写出两个范例。

 1 查询:匿名类型形式
 2 
 3  
 4 
 5 我们使用下面代码来查询出ShipCity 在London的发票。
 6 
 7  
 8 
 9 var q =
10 
11   from i in db.Invoices
12 
13   where i.ShipCity == "London"
14 
15   select new
16 
17   {
18 
19     i.OrderID,
20 
21      i.ProductName,
22 
23     i.Quantity,
24 
25     i.CustomerName
26 
27   };
28 
29  
30 
31 这里,生成的SQL语句同使用数据表类似:
32 
33  
34 
35 SELECT [t0].[OrderID], [t0].[ProductName],[t0]. [Quantity],
36 
37 [t0].[CustomerName] FROM [dbo].[Invoices]AS [t0]
38 
39 WHERE [t0].[ShipCity] = @p0
40 
41 -- @p0: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
查询:匿名类型形式
 1 查询:标识映射形式
 2 
 3  
 4 
 5 下例查询出每季的订单。
 6 
 7  
 8 
 9 var q =
10 
11   from qo in db.Quarterly_Orders
12 
13   select qo;
14 
15  
16 
17 生成SQL语句为:
18 
19  
20 
21 SELECT [t0].[CustomerID],[t0].[CompanyName], [t0]. [City],
22 
23 [t0].[Country] FROM [dbo].[QuarterlyOrders] AS [t0]
查询:标识映射形式

LINQ to SQL语句(25)之继承

 1 继承支持
 2 
 3  
 4 
 5 LINQ to SQL 支持单表映射,其整个继承层次结构存储在单个数据库表中。该表包含整个层次结构的所有可能数据列的平展联合。(联合是将两个表组合成一个表的结果,组合后的表包含任一原始表中存在的行。)每行中不适用于该行所表示的实例类型的列为 null 6 
 7  
 8 
 9 单表映射策略是最简单的继承表示形式,为许多不同类别的查询提供了良好的性能特征,如果我们要在 LINQ to SQL 中实现这种映射,必须在继承层次结构的根类中指定属性 (Attribute) 和属性 (Attribute) 的属性 (Property)。我们还可以使用O/R设计器来映射继承层次结构,它自动生成了代码。
10 
11  
12 
13 下面为了演示下面的几个例子,我们在O/R设计器内设计如下图所示的类及其继承关系。
14 
15  
16 
17 我们学习的时候还是看看其生成的代码吧!
18 
19  
20 
21 具体设置映射继承层次结构有如下几步:
22 
23  
24 
25 根类添加TableAttribute属性。
26 
27  
28 
29 为层次结构中的每个类添加InheritanceMappingAttribute属性,同样是添加到根类中。每个InheritanceMappingAttribute属性,定义一个Code属性和一个Type属性。Code 属性的值显示在数据库表的IsDiscriminator列中,用来指示该行数据所属的类或子类。Type属性值指定键值所表示的类或子类。
30 
31  
32 
33 仅在其中一个 InheritanceMappingAttribute属性上,添加一个IsDefault属性用来在数据库表 中的鉴别器值在继承映射中不与任何Code值匹配时指定回退映射。
34 
35  
36 
37 为 ColumnAttribute属性添加一个IsDiscriminator属性来表示这是保存Code值的列。
38 
39  
40 
41 下面是这张图生成的代码的框架(由于生成的代码太多,我删除了很多“枝叶”,仅仅保留了主要的框架用于指出其实质的东西):
42 
43  
44 
45 [Table(Name = "dbo.Contacts")]
46 
47 [InheritanceMapping(Code ="Unknown", Type = typeof (Contact),
48 
49           IsDefault = true)]
50 
51 [InheritanceMapping(Code ="Employee", Type = typeof (EmployeeContact))]
52 
53 [InheritanceMapping(Code ="Supplier", Type = typeof(SupplierContact))]
54 
55 [InheritanceMapping(Code ="Customer", Type = typeof (CustomerContact))]
56 
57 [InheritanceMapping(Code ="Shipper", Type = typeof(ShipperContact))]
58 
59 public partial class Contact :
60 
61 INotifyPropertyChanging,INotifyPropertyChanged
62 
63 {
64 
65   [Column(Storage = "_ContactID",IsPrimaryKey = true,
66 
67   IsDbGenerated = true)]
68 
69   public int ContactID{ }
70 
71   [Column(Storage = "_ContactType",IsDiscriminator = true)]
72 
73   public string ContactType{ }
74 
75 }
76 
77 public abstract partial class FullContact :Contact{ }
78 
79 public partial class EmployeeContact :FullContact{ }
80 
81 public partial class SupplierContact :FullContact{ }
82 
83 public partial class CustomerContact :FullContact{ }
84 
85 public partial class ShipperContact :Contact{ }
继承支持(概念,代码框架)
 1 1.一般形式
 2 
 3  
 4 
 5 日常我们经常写的形式,对单表查询。
 6 
 7  
 8 
 9 var cons = from c in db.Contacts
10 
11       select c;
12 
13 foreach (var con in cons) {
14 
15    Console.WriteLine("Company name: {0}", con.CompanyName);
16 
17   Console.WriteLine("Phone: {0}", con.Phone);
18 
19    Console.WriteLine("This is a {0}", con.GetType());
20 
21 }
1.一般形式
 1 2.OfType形式
 2 
 3  
 4 
 5 这里我仅仅让其返回顾客的联系方式。
 6 
 7  
 8 
 9 var cons = from c indb.Contacts.OfType<CustomerContact>()
10 
11       select c;
12 
13  
14 
15 初步学习,我们还是看看生成的SQL语句,这样容易理解。在 SQL语句中查询了ContactType为Customer的联系方式。
16 
17  
18 
19 SELECT [t0].[ContactType],[t0].[ContactName], [t0].[ContactTitle],
20 
21 [t0].[Address],[t0].[City], [t0].[Region],[t0].[PostalCode],
22 
23 [t0].[Country],[t0].[Fax],[t0].[ContactID], [t0].[CompanyName],
24 
25 [t0].[Phone] FROM [dbo].[Contacts] AS [t0]
26 
27 WHERE ([t0]. [ContactType] = @p0) AND([t0].[ContactType] IS NOT NULL)
28 
29 -- @p0: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Customer]
2.OfType形式
 1 3.IS形式
 2 
 3  
 4 
 5 这个例子查找一下发货人的联系方式。
 6 
 7  
 8 
 9 var cons = from c in db.Contacts
10 
11       where c is ShipperContact
12 
13       select c;
14 
15  
16 
17 生成的SQL语句如下:查询了ContactType为Shipper的联系方式。大致一看好像很上面的一样,其实这里查询出来的列多了很多。实际上是Contacts表的全部字段。
18 
19  
20 
21 SELECT [t0].[ContactType],[t0].[ContactID], [t0]. [CompanyName],
22 
23 [t0].[Phone],[t0].[HomePage], [t0].[ContactName],
24 
25 [t0].[ContactTitle], [t0].[Address], [t0].[City],
26 
27 [t0].[Region], [t0].[PostalCode],[t0].[Country],
28 
29 [t0].[Fax],[t0].[PhotoPath], [t0].[Photo],[t0].[Extension]
30 
31 FROM [dbo].[Contacts] AS [t0] WHERE([t0].[ContactType] = @p0)
32 
33 AND ([t0].[ContactType] IS NOT NULL)
34 
35 -- @p0: Input NVarChar (Size = 7; Prec = 0;Scale = 0) [Shipper]
3.IS形式
 1 4.AS形式
 2 
 3  
 4 
 5 这个例子就通吃了,全部查找了一番。
 6 
 7  
 8 
 9 var cons = from c in db.Contacts
10 
11       select c as FullContact;
12 
13  
14 
15 生成 SQL语句如下:查询整个Contacts表。
16 
17  
18 
19 SELECT [t0]. [ContactType],[t0].[HomePage], [t0].[ContactName],
20 
21 [t0]. [ContactTitle],[t0].[Address],[t0].[City],
22 
23 [t0].[Region], [t0]. [PostalCode],[t0].[Country],
24 
25 [t0].[Fax], [t0].[ContactID],[t0].[CompanyName],
26 
27 [t0].[Phone],[t0].[PhotoPath],[t0].[Photo], [t0].[Extension]
28 
29 FROM [dbo].[Contacts] AS [t0]
4.AS形式
 1 5.Cast形式
 2 
 3  
 4 
 5 使用Case形式查找出在伦敦的顾客的联系方式。
 6 
 7  
 8 
 9 var cons = from c in db.Contacts
10 
11       where c.ContactType == "Customer" &&
12 
13            ((CustomerContact)c).City == "London"
14 
15       select c;
16 
17  
18 
19 生成SQL语句如下,自己可以看懂了。
20 
21  
22 
23 SELECT [t0].[ContactType],[t0].[ContactID], [t0]. [CompanyName],
24 
25 [t0].[Phone], [t0].[HomePage],[t0].[ContactName],
26 
27 [t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region],
28 
29 [t0].[PostalCode], [t0].[Country],[t0].[Fax], [t0].[PhotoPath],
30 
31 [t0].[Photo], [t0].[Extension]FROM [dbo].[Contacts] AS [t0]
32 
33 WHERE ([t0].[ContactType] = @p0) AND ([t0].[City] = @p1)
34 
35 -- @p0: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Customer]
36 
37 -- @p1: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
5.Cast形式
 1 6.UseAsDefault形式
 2 
 3  
 4 
 5 当插入一条记录时,使用默认的映射关系了,但是在查询时,使用继承的关系了。具体看看生成的SQL 语句就直截了当了。
 6 
 7  
 8 
 9 //插入一条数据默认使用正常的映射关系
10 
11 Contact contact = new Contact()
12 
13 {
14 
15   ContactType = null,
16 
17   CompanyName = "Unknown Company",
18 
19    Phone = "333-444-5555"
20 
21 };
22 
23 db.Contacts.InsertOnSubmit(contact);
24 
25 db.SubmitChanges();
26 
27 //查询一条数据默认使用继承映射关系
28 
29 var con =
30 
31   (from c in db.Contacts
32 
33    where c.CompanyName == "Unknown Company" &&
34 
35               c.Phone == "333-444-5555"
36 
37    select c).First();
38 
39  
40 
41 生成SQL语句如下:
42 
43  
44 
45 INSERT INTO [dbo].[Contacts]([ContactType], [CompanyName],
46 
47 [Phone]) VALUES (@p0, @p1, @p2)
48 
49 SELECT TOP (1) [t0].[ContactType], [t0].[ContactID],
50 
51 [t0]. [CompanyName],[t0].[Phone],[t0].[HomePage],
52 
53 [t0].[ContactName], [t0].[ContactTitle],[t0].[Address],
54 
55 [t0].[City],[t0].[Region],[t0].[PostalCode], [t0].[Country],
56 
57 [t0].[Fax], [t0].[PhotoPath], [t0].[Photo],[t0].[Extension]
58 
59 FROM [dbo].[Contacts] AS [t0]
60 
61 WHERE ([t0].[CompanyName] = @p0) AND([t0].[Phone] = @p1)
62 
63 -- @p0: Input NVarChar (Size = 15; Prec =0; Scale = 0)
64 
65   [Unknown Company]
66 
67 -- @p1: Input NVarChar (Size = 12; Prec =0; Scale = 0)
68 
69   [333-444-5555]
6.UseAsDefault形式
  1 7.插入新的记录
  2 
  3  
  4 
  5 这个例子说明如何插入发货人的联系方式的一条记录。
  6 
  7  
  8 
  9 //
 10 
 11  
 12 
 13 1.在插入之前查询一下,没有数据
 14 
 15 var ShipperContacts =
 16 
 17   from sc in db.Contacts.OfType<ShipperContact>()
 18 
 19   where sc.CompanyName == "Northwind Shipper"
 20 
 21   select sc;
 22 
 23 //
 24 
 25  
 26 
 27 2.插入数据
 28 
 29 ShipperContact nsc = new ShipperContact()
 30 
 31 {
 32 
 33   CompanyName = "Northwind Shipper",
 34 
 35   Phone = "(123)-456-7890"
 36 
 37 };
 38 
 39 db.Contacts.InsertOnSubmit(nsc);
 40 
 41 db.SubmitChanges();
 42 
 43 //
 44 
 45  
 46 
 47 3.查询数据,有一条记录
 48 
 49 ShipperContacts =
 50 
 51   from sc in db.Contacts.OfType<ShipperContact>()
 52 
 53    where sc.CompanyName == "Northwind Shipper"
 54 
 55   select sc;
 56 
 57 //
 58 
 59  
 60 
 61 4.删除记录
 62 
 63 db.Contacts.DeleteOnSubmit (nsc);
 64 
 65 db.SubmitChanges();
 66 
 67  
 68 
 69 生成SQL语句如下:
 70 
 71  
 72 
 73 SELECT COUNT(*) AS [value] FROM[dbo].[Contacts] AS [t0]
 74 
 75 WHERE ([t0].[CompanyName] = @p0) AND([t0].[ContactType] = @p1)
 76 
 77 AND ([t0].[ContactType] IS NOT NULL)
 78 
 79 -- @p0: Input NVarChar [Northwind Shipper]
 80 
 81 -- @p1: Input NVarChar [Shipper]
 82 
 83 INSERT INTO [dbo].[Contacts]([ContactType],[CompanyName], [Phone])
 84 
 85 VALUES (@p0, @p1, @p2)
 86 
 87 -- @p0: Input NVarChar [Shipper]
 88 
 89 -- @p1: Input NVarChar [NorthwindShipper]
 90 
 91 -- @p2: Input NVarChar [(123)-456-7890]
 92 
 93 SELECT COUNT(*) AS [value] FROM[dbo].[Contacts] AS [t0]
 94 
 95 WHERE ([t0].[CompanyName] = @p0) AND([t0].[ContactType] = @p1)
 96 
 97 AND ([t0].[ContactType] IS NOT NULL)
 98 
 99 -- @p0: Input NVarChar [Northwind Shipper]
100 
101 -- @p1: Input NVarChar [Shipper]
102 
103 DELETE FROM [dbo].[Contacts] WHERE ([ContactID]= @p0) AND
104 
105 ([ContactType] = @p1) AND ([CompanyName] =@p2) AND ([Phone] = @p3)
106 
107 -- @p0: Input Int [159]
108 
109 -- @p1: Input NVarChar [Shipper]
110 
111 -- @p2: Input NVarChar [NorthwindShipper]
112 
113 -- @p3: Input NVarChar [(123)-456-7890]
114 
115 -- @p4: Input NVarChar [Unknown]
116 
117 -- @p5: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Supplier]
118 
119 -- @p6: Input NVarChar (Size = 7; Prec = 0;Scale = 0) [Shipper]
120 
121 -- @p7: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Employee]
122 
123 -- @p8: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Customer]
7.插入新的记录

 

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。

暂无文章

是否有可能从另一个git存储库中挑选一个提交? - Is it possible to cherry-pick a commit from another git repository?

问题: I'm working with a git repository that needs a commit from another git repository that knows nothing of the first. 我正在使用一个git存储库,需要从另一个不知道第一个存储库......

技术盛宴
昨天
26
0
【LeetCode】53 盛最多水的容器

题目 解题思路 双指针法: https://leetcode-cn.com/problems/container-with-most-water/solution/sheng-zui-duo-shui-de-rong-qi-by-leetcode-solution/ 代码 public class Solution { ......

JaneRoad
昨天
16
0
阿里云OSS配置CDN加速

首先购买CDN流量包 然后添加域名 添加好后 然后将域名OSS.xxxx.com 解析到 生成的CDN域名上 这样就完成了

可达鸭眉头一皱
昨天
16
0
js 整数与小数正则替换片段

说明 /(\d+)/g 整数 /(\d+\.\d+)rem/g 小数 /(\d+\.\d+|\d+)rem/g 其中 | 或 条件 例子 全局查找带 rem 单位的,替换成 px 单位 let text = text.replace(/(\d+\.\d+|\d+)rem/g, function(s......

DrChenXX
昨天
17
0
ubuntu下minicorba例子

一、开发环境安装 sudo apt install omniorb omniorb-idl omniidl libomniorb4-dev libomniorb4-2 omniorb-nameserver libomnithread4 libomnithread4-dev 二、源文件: Hi.idl module ......

wangxuwei
昨天
18
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部