标签：des blog http 使用 os io strong 文件
适用场景：实现过滤，查询等功能。
说明：与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;
筛选库存量在订货点水平之下但未断货的产品：
var q =
from p in db.Products
where p.UnitsInStock <= p.ReorderLevel && !p.Discontinued
select p;
筛选出UnitPrice 大于10 或已停产的产品：
var q =
from p in db.Products
where p.UnitPrice > 10m || p.Discontinued
select p;
以下这个样例是调用两次where以筛选出UnitPrice大于10且已停产的产品。
var q =
db.Products.Where(p=>p.UnitPrice > 10m).Where(p=>p.Discontinued);
返回集合中的一个元素，事实上质就是在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);
[1] Select介绍1
[2] Select介绍2
[3] Select介绍3和 Distinct介绍
Select/Distinct操作符
适用场景：o(∩_∩) o…查询呗。
说明：和SQL命令中的select作用相似但位置不同，查询表达式中的select及所接子句是放在表达式最后并把子句中的变量也就是结果返回回来；延迟。
Select/Distinct操作包含9种形式，分别为简单用 法、匿名类型形式、条件形式、指定类型形式、筛选形式、整形类型形式、嵌套类型形式、本地方法调用形式、Distinct形式。
这个演示样例返回仅含客户联系人姓名的序列。
var q =
from c in db.Customers
select c.ContactName;
注意：这个语句仅仅是一个声明或者一个描写叙述，并没有真正把数据取出来，仅仅有当你须要该数据的时候，它才会运行这个语句，这就是延迟载入(deferred loading)。假设，在声明的时候就返回的结果集是对象的集合。你能够使用ToList() 或ToArray()方法把查询结果先进行保存，然后再对这个集合进行查询。当然延迟载入(deferred loading)能够像拼接SQL语句那样拼接查询语法，再运行它。
说明：匿名类型是C#3.0中新特性。事实上质是编译器依据我们自己定义自己主动产生一个匿名的类来帮助我们实现暂时变量的储存。匿名类型还依赖于另外一个特性：支持依据property来创建对象。比方，var d = new { Name = "s" };编译器自己主动产生一个有property叫做Name的匿名类，然后按这 个类型分配内存，并初始化对象。可是var d = new {"s"};是编译不 通过的。由于，编译器不知道匿名类中的property的名字。比如stringc = "d";var d = new { c}; 则是能够通过编译的。编译器会创建一个叫 做匿名类带有叫c的property。
比例如以下例：new {c,ContactName,c.Phone};ContactName和Phone都是在映射文件里定义与表中字 段相相应的property。编译器读取数据并创建对象时，会创建一个匿名类，这个 类有两个属性，为ContactName和Phone，然后依据数据初始化对象。另外编译器 还能够重命名property的名字。
var q =
from c in db.Customers
select new {c.ContactName, c.Phone};
上面语句描写叙述：使用 SELECT 和匿名类型返回仅含客户联系人姓名和电话号码的序列
var q =
from e in db.Employees
select new
{
Name = e.FirstName + " " + e.LastName,
Phone = e.HomePhone
};
上面语句描写叙述：使用SELECT和匿名类型返回仅含雇员姓名和电话号码的序列，并将 FirstName和LastName字段合并为一个字段“Name”，此外在所得的序列中将HomePhone字段重命名为Phone。
var q =
from p in db.Products
select new
{
p.ProductID,
HalfPrice = p.UnitPrice / 2
};
上面语句描写叙述：使用SELECT和匿名类型返回全部产品的ID以及 HalfPrice(设置为产品单位价格除以2所得的值)的序列。
说明：生成SQL语句为：case when condition then else。
var q =
from p in db.Products
select new
{
p.ProductName,
Availability =
p.UnitsInStock - p.UnitsOnOrder < 0 ?
"Out Of Stock" : "In Stock"
};
上面语句描写叙述：使用SELECT和条件语句返回产品名称和产品供货状态的序列。
说明：该形式返回你自己定义类型的对象集。
var q =
from e in db.Employees
select new Name
{
FirstName = e.FirstName,
LastName = e.LastName
};
上面语句描写叙述：使用SELECT和已知类型返回雇员姓名的序列。
说明：结合where使用，起到过滤作用。
var q =
from c in db.Customers
where c.City == "London"
select c.ContactName;
上面语句描写叙述：使用SELECT和WHERE返回仅含伦敦客户联系人姓名的序列。
说明：其select操作使用了匿名对象，而这个匿名对象中，其属性也是个匿名对象。
var q =
from c in db.Customers
select new {
c.CustomerID,
CompanyInfo = new {c.CompanyName, c.City, c.Country},
ContactInfo = new {c.ContactName, c.ContactTitle}
};
语句描写叙述：使用 SELECT 和匿名类型返回有关客户的数据的整形子集。查询顾客的ID和公司信息（公司名称，城市，国家）以及联系信息（联系人和职位）。
说明：返回的对象集中的每一个对象DiscountedProducts属性中，又包括一个集合。也就是每一个对象也是一个集合类。
var q =
from o in db.Orders
select new {
o.OrderID,
DiscountedProducts =
from od in o.OrderDetails
where od.Discount > 0.0
select od,
FreeShippingDiscount = o.Freight
};
语句描写叙述：使用嵌套查询返回全部订单及其OrderID 的序列、打折订单中项目的子序列以及免送货所省下的金额。
这个样例在查询中调用本地方法 PhoneNumberConverter将电话号码转换为国际格式。
var q = from c in db.Customers
where c.Country == "UK" || c.Country == "USA"
select new
{
c.CustomerID,
c.CompanyName,
Phone = c.Phone,
InternationalPhone =
PhoneNumberConverter(c.Country, c.Phone)
};
PhoneNumberConverter方法例如以下：
public string PhoneNumberConverter(stringCountry, string Phone)
{
Phone = Phone.Replace(" ", "").Replace(")", ")-");
switch (Country)
{
case "USA":
return "1- " + Phone;
case "UK":
return "44-" + Phone;
default:
return Phone;
}
}
以下也是使用了这种方法将电话号码转换为国际格式并创建XDocument
XDocument doc = new XDocument(
new XElement("Customers", from c in db.Customers
where c.Country == "UK" || c.Country == "USA"
select (new XElement ("Customer",
new XAttribute ("CustomerID", c.CustomerID),
new XAttribute("CompanyName", c.CompanyName),
new XAttribute("InterationalPhone",
PhoneNumberConverter(c.Country, c.Phone))
))));
说明：筛选字段中不同样的值。用于查询不反复的结果集。生成SQL语句为：SELECT DISTINCT [City] FROM [Customers]
var q = (
from c in db.Customers
select c.City )
.Distinct();
语句描写叙述：查询顾客覆盖的国家。
[1] Count/Sum解说
[2] Min解说
[3] Max解说
[4] Average和Aggregate解说
Count/Sum/Min/Max/Avg操作符
适用场景：统计数据吧，比方统计一些数据的个数，求和，最小值，最大值，平均数。
Count
说明：返回集合中的元素个数，返回INT类型；不延迟。生成 SQL语句为：SELECT COUNT(*) FROM
得到数据库中客户的数量：
var q = db.Customers.Count();
得到数据库中未断货产品的数量：
var q = db.Products.Count(p =>!p.Discontinued);
LongCount
说明：返回集合中的元素个数，返回LONG类型；不延迟。对于元素个数较多的集合可视情况能够选用LongCount来统计元素个数，它返回long类型，比較精确。生成 SQL语句为：SELECT COUNT_BIG(*) FROM
var q = db.Customers.LongCount();
Sum
说明：返回集合中数值类型元素之和，集合应为INT类型集合；不延迟。生成SQL语句为：SELECT SUM(…) FROM
得到全部订单的总运费：
var q = db.Orders.Select(o =>o.Freight).Sum();
得到全部产品的订货总数：
var q = db.Products.Sum(p =>p.UnitsOnOrder);
Min
说明：返回集合中元素的最小值；不延迟。生成SQL语句为：SELECT MIN(…) FROM
1.简单形式：
查找随意产品的最低单位价格：
var q = db.Products.Select(p => p.UnitPrice).Min();
2.映射形式：
查找随意订单的最低运费：
var q = db.Orders.Min(o => o.Freight);
查找每一个类别中单位价格最低的产品：
var categories =
from p in db.Products
group p by p.CategoryID into g
select new {
CategoryID = g.Key,
CheapestProducts =
from p2 in g
where p2.UnitPrice == g.Min(p3 => p3.UnitPrice)
select p2
};
Max
说明：返回集合中元素的最大值；不延迟。生成SQL语句为：SELECT MAX(…) FROM
查找随意雇员的近期雇用日期：
var q = db.Employees.Select(e => e.HireDate).Max();
查找随意产品的最大库存量：
var q = db.Products.Max(p =>p.UnitsInStock);
查找每一个类别中单位价格最高的产品：
var categories =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
MostExpensiveProducts =
from p2 in g
where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
select p2
};
Average
说明：返回集合中的数值类型元素的平均值。集合应为数字类型集合，其返回值类型为double；不延迟。生成SQL语句为：SELECT AVG(…) FROM
得到全部订单的平均运费：
var q = db.Orders.Select(o =>o.Freight).Average();
得到全部产品的平均单位价格：
var q = db.Products.Average(p => p.UnitPrice);
查找每一个类别中单位价格高于该类别平均单位价格的产品：
var categories =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
ExpensiveProducts =
from p2 in g
where p2.UnitPrice > g.Average (p3 => p3.UnitPrice)
select p2
};
Aggregate
说明：依据输入的表达式获取聚合值；不延迟。即是说：用一个种子值与当前元素通过指定的函数来进行对照来遍历集合中的元素，符合条件的元素保留下来。假设没有指定种子值的话，种子值默觉得集合的第一个元素。
适用场景：在我们表关系中有一对一关系，一对多关系，多对多关系等。对各个表之间的关系，就用这些实现对多个表的操作。
说明：在Join操作中，分别为Join(Join查询), SelectMany(Select一对多选择) 和GroupJoin(分组Join查询)。
该扩展方法对两个序列中键匹配的元素进行inner join操作
SelectMany
说明：我们在写查询语句时，假设被翻译成SelectMany须要满足2个条件。1：查询语句中没有join和into，2：必须出现EntitySet。在我们表关系中有一对一关系，一对多关系，多对多关系等，以下分别介绍一下。
var q =
from c in db.Customers
from o in c.Orders
where c.City == "London"
select o;
语句描写叙述：Customers与Orders是一对多关系。即Orders在Customers类中以 EntitySet形式出现。所以第二个from是从c.Orders而不是db.Orders里进行筛选。这个样例在From子句中使用外键导航选择伦敦客户的全部订单。
var q =
from p in db.Products
where p.Supplier.Country == "USA" &&p.UnitsInStock == 0
select p;
语句描写叙述：这一句使用了 p.Supplier.Country条件，间接关联了Supplier表。这个样例在Where子句中使用外键导航筛选其供应商在美国且缺货的产品。生成SQL语句为：
SELECT [t0].[ProductID],[t0].[ProductName], [t0]. [SupplierID],
[t0].[CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice],
[t0].[UnitsInStock],[t0].[UnitsOnOrder],[t0]. [ReorderLevel],
[t0].[Discontinued] FROM [dbo].[Products]AS [t0]
LEFT OUTER JOIN [dbo].[Suppliers] AS [t1]ON
[t1]. [SupplierID] = [t0].[SupplierID]
WHERE ([t1].[Country] = @p0) AND([t0].[UnitsInStock] = @p1)
-- @p0: Input NVarChar (Size = 3; Prec = 0;Scale = 0) [USA]
-- @p1: Input Int (Size = 0; Prec = 0;Scale = 0) [0]
var q =
from e in db.Employees
from et in e.EmployeeTerritories
where e.City == "Seattle"
select new
{
e.FirstName,
e.LastName,
et.Territory.TerritoryDescription
};
说明：多对多关系通常会涉及三个表(假设有一个表是自关联的，那有可能仅仅有2个表)。这一句语句涉及Employees, EmployeeTerritories, Territories三个表。它们的关系是1：M：1。Employees 和Territories没有非常明白的关系。
语句描写叙述：这个样例在From子句中使用外键导航筛选在西雅图的雇员，同一时候列出其所在地区。这条生成SQL语句为：
SELECT [t0].[FirstName], [t0].[LastName],[t2]. [TerritoryDescription]
FROM [dbo].[Employees] AS [t0] CROSS JOIN[dbo].[EmployeeTerritories]
AS [t1] INNER JOIN [dbo]. [Territories] AS[t2] ON
[t2].[TerritoryID] = [t1].[TerritoryID]
WHERE ([t0].[City] = @p0) AND([t1].[EmployeeID] = [t0]. [EmployeeID])
-- @p0: Input NVarChar (Size = 7; Prec = 0;Scale = 0) [Seattle]
var q =
from e1 in db.Employees
from e2 in e1.Employees
where e1.City == e2.City
select new {
FirstName1 = e1.FirstName, LastName1 = e1.LastName,
FirstName2 = e2.FirstName, LastName2 = e2.LastName,
e1.City
};
语句描写叙述：这个样例在select 子句中使用外键导航筛选成对的雇员，每对中一个雇员隶属于还有一个雇员，且两个雇员都来自同样城市。生成SQL语句为：
SELECT [t0].[FirstName] AS [FirstName1],[t0].[LastName] AS
[LastName1],[t1].[FirstName] AS[FirstName2], [t1].[LastName] AS
[LastName2],[t0].[City] FROM[dbo].[Employees] AS [t0],
[dbo].[Employees] AS [t1] WHERE([t0].[City] = [t1]. [City]) AND
([t1].[ReportsTo] = [t0].[EmployeeID])
GroupJoin
像上面所说的，没有join和into，被翻译成 SelectMany，同一时候有join和into时，那么就被翻译为GroupJoin。在这里into的概念是对其结果进行又一次命名。
此演示样例显式联接两个表并从这两个表投影出结果：
var q =
from c in db.Customers
join o in db.Orders on c.CustomerID
equals o.CustomerID into orders
select new
{
c.ContactName,
OrderCount = orders.Count ()
};
说明：在一对多关系中，左边是1，它每条记录为c（from c in db.Customers），右边是Many，其每条记录叫做o ( join o in db.Orders )，每相应左边的一个c，就会有一组o，那这一组o，就叫做orders， 也就是说，我们把一组o命名为orders，这就是into用途。这也就是为什么在select语句中，orders能够调用聚合函数Count。在T-SQL中，使用其内嵌的T- SQL返回值作为字段值。如图所看到的：
生成SQL语句为：
SELECT [t0].[ContactName], (
SELECT COUNT(*)
FROM [dbo].[Orders] AS [t1]
WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [OrderCount]
FROM [dbo].[Customers] AS [t0]
此演示样例显式联接三个表并分别从每一个表投影出结果：
var q =
from c in db.Customers
join o in db.Orders on c.CustomerID
equals o.CustomerID into ords
join e in db.Employees on c.City
equals e.City into emps
select new
{
c.ContactName,
ords = ords.Count(),
emps = emps.Count()
};
生成SQL语句为：
SELECT [t0]. [ContactName], (
SELECT COUNT(*)
FROM [dbo].[Orders] AS [t1]
WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [ords], (
SELECT COUNT(*)
FROM [dbo].[Employees] AS [t2]
WHERE [t0].[City] = [t2].[City]
) AS [emps]
FROM [dbo].[Customers] AS [t0]
此演示样例说明怎样通过使用此演示样例说明怎样通过使用 DefaultIfEmpty() 获取左外部联接。在雇员没有订单时，DefaultIfEmpty()方法返回null：
var q =
from e in db.Employees
join o in db.Orders on e equals o.Employee into ords
from o in ords.DefaultIfEmpty()
select new
{
e.FirstName,
e.LastName,
Order = o
};
说明：以Employees左表，Orders右表，Orders 表中为空时，用null值填充。Join的结果重命名ords，使用DefaultIfEmpty()函数对其再次查询。其最后的结果中有个Order，由于from o in ords.DefaultIfEmpty() 是对 ords组再一次遍历，所以，最后结果中的Order并非一个集合。可是，假设没有from o in ords.DefaultIfEmpty() 这句，最后的select语句写成selectnew { e.FirstName, e.LastName, Order = ords }的话，那么Order就是一个集合。
说明：let语句是重命名。let位于第一个from和select语句之间。
这个样例从联接投影出终于“Let”表达式：
var q =
from c in db.Customers
join o in db.Orders on c.CustomerID
equals o.CustomerID into ords
let z = c.City + c.Country
from o in ords
select new
{
c.ContactName,
o.OrderID,
z
};
这个样例显示带有组合键的联接：
var q =
from o in db.Orders
from p in db.Products
join d in db.OrderDetails
on new
{
o.OrderID,
p.ProductID
} equals
new
{
d.OrderID,
d.ProductID
}
into details
from d in details
select new
{
o.OrderID,
p.ProductID,
d.UnitPrice
};
说明：使用三个表，而且用匿名类来说明：使用三个表，而且用匿名类来表示它们之间的关系。它们之间的关系不能用一个键描写叙述清楚，所以用匿名类，来表示组合键。另一种是两个表之间是用组合键表示关系的，不须要使用匿名类。
这个实例显示怎样构造一側可为 null 而还有一側不可为 null 的联接：
var q =
from o in db.Orders
join e in db.Employees
on o.EmployeeID equals
(int?)e.EmployeeID into emps
from e in emps
select new
{
o.OrderID,
e.FirstName
};
适用场景：对查询出的语句进行排序，比方按时间排序等等。
说明：按指定表达式对集合排序；延迟，：按指定表达式对集合排序；延迟，默认是升序，加上descending表示降序，相应的扩展方法是 OrderBy和OrderByDescending
这个样例使用 orderby 按雇用日期对雇员进行排序：
var q =
from e in db.Employees
orderby e.HireDate
select e;
说明：默觉得升序
注意：Where 和Order By的顺序并不重要。而在T-SQL中，Where和Order By有严格的位置限制。
var q =
from o in db.Orders
where o.ShipCity == "London"
orderby o.Freight
select o;
语句描写叙述：使用where和orderby按运费进行排序。
var q =
from p in db.Products
orderby p.UnitPrice descending
select p;
语句描写叙述：使用复合的 orderby 对客户进行排序，进行排序：
var q =
from c in db.Customers
orderby c.City, c.ContactName
select c;
说明：按多个表达式进行排序，比如先按City排序，当City同样时，按ContactName排序。这一句用Lambda表达式像这样写：
var q =
.OrderBy(c => c.City)
.ThenBy(c => c.ContactName).ToList();
在T-SQL中没有 ThenBy语句，其依旧翻译为OrderBy，所以也能够用以下语句来表达：
var q =
db.Customers
.OrderBy(c => c.ContactName)
.OrderBy(c => c.City).ToList ();
所要注意的是，多个OrderBy操作时，级连方式是按逆序。对于降序的，用对应的降序操作符替换就可以。
var q =
db.Customers
.OrderByDescending(c => c.City)
.ThenByDescending(c => c.ContactName).ToList();
须要说明的是，OrderBy操作，不支持按type排序，也不支持匿名类。比方
var q =
db.Customers
.OrderBy(c => new
{
c.City,
c.ContactName
}).ToList();
会被抛出异常。错误是前面的操作有匿名类，再跟OrderBy时，比較的是类别。比方
var q =
db.Customers
.Select(c => new
{
c.City,
c.Address
})
.OrderBy(c => c).ToList();
假设你想使用OrderBy(c => c)，其前提条件是，前面步骤中，所产生的对象的类别必须为C#语言的基本类型。比方下句，这里 City为string类型。
var q =
db.Customers
.Select(c => c.City)
.OrderBy(c => c).ToList ();
这两个扩展方式都是用在 OrderBy/OrderByDescending之后的，第一个ThenBy/ThenByDescending扩展方法 作为第二位排序根据，第二个ThenBy/ThenByDescending则作为第三位排序根据 ，以此类推
var q =
from o in db.Orders
where o.EmployeeID == 1
orderby o.ShipCountry, o.Freight descending
select o;
语句描写叙述：使用orderby先按发往国家再按运费从高到低的顺序对 EmployeeID 1 的订单进行排序。
var q =
from p in db.Products
group p by p.CategoryID into g
orderby g.Key
select new {
g.Key,
MostExpensiveProducts =
from p2 in g
where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
select p2
};
语句描写叙述：使用orderby、Max 和 Group By 得出每种类别中单位价格最高的产品，并按 CategoryID 对这组产品进行排序。
适用场景：分组数据，为我们查找数据缩小范围。
说明：分配并返回对传入參数进行分组操作后的可枚举对象。分组；延迟
var q =
from p in db.Products
group p by p.CategoryID into g
select g;
语句描写叙述：使用Group By按CategoryID划分产品。
说明：from p in db.Products 表示从表中将产品对象取出来。group p by p.CategoryID into g表示对p按CategoryID字段归类。其结果命名为g，一旦重 新命名，p的作用域就结束了，所以，最后select时，仅仅能select g。当然，也不必又一次命名能够这样写：
var q =
from p in db.Products
group p by p.CategoryID;
我们用示意图表示：
假设想遍历某类别中全部记录，这样：
foreach (var gp in q)
{
if (gp.Key == 2)
{
foreach (var item in gp)
{
//do something
}
}
}
var q =
from p in db.Products
group p by p.CategoryID into g
select new { CategoryID = g.Key, g };
说明：在这句LINQ语句中，有2个property：CategoryID和g。这个匿名类，事实上质是对返回结果集又一次进行了包装。把g的property封装成一个完整的分组。例如以下图所看到的：
假设想遍历某匿名类中全部记录，要这么做：
foreach (var gp in q)
{
if (gp.CategoryID == 2)
{
foreach (var item in gp.g)
{
//do something
}
}
}
var q =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
MaxPrice = g.Max(p => p.UnitPrice)
};
语句描写叙述：使用Group By和Max查找每一个CategoryID的最高单位价格。
说明：先按CategoryID归类，推断各个分类产品中单位价格最大的 Products。取出CategoryID值，并把UnitPrice值赋给MaxPrice。
var q =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
MinPrice = g.Min(p => p.UnitPrice)
};
语句描写叙述：使用Group By和Min查找每一个CategoryID的最低单位价格。
说明：先按CategoryID归类，推断各个分类产品中单位价格最小的 Products。取出CategoryID值，并把UnitPrice值赋给MinPrice。
var q =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
AveragePrice = g.Average(p => p.UnitPrice)
};
语句描写叙述：使用Group By和Average得到每一个CategoryID的平均单位价格。
说明：先按CategoryID归类，取出CategoryID值和各个分类产品中单位价格的平均值。
var q =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
TotalPrice = g.Sum(p => p.UnitPrice)
};
语句描写叙述：使用Group By和Sum得到每一个CategoryID 的单位价格总计。
说明：先按CategoryID归类，取出 CategoryID值和各个分类产品中单位价格的总和。
var q =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
NumProducts = g.Count()
};
语句描写叙述：使用Group By和Count得到每一个CategoryID中产品的数量。
说明：先按CategoryID归类，取出 CategoryID值和各个分类产品的数量。
var q =
from p in db.Products
group p by p.CategoryID into g
select new {
g.Key,
NumProducts = g.Count(p => p.Discontinued)
};
语句描写叙述：使用Group By和Count得到每一个CategoryID中断货产品的数量。
说明：先按 CategoryID归类，取出CategoryID值和各个分类产品的断货数量。Count函数里，使用了Lambda表达式，Lambda表达式中的p，代表这个组里的一个元素或对象，即某一个产品。
var q =
from p in db.Products
group p by p.CategoryID into g
where g.Count() >= 10
select new {
g.Key,
ProductCount = g.Count()
};
语句描写叙述：依据产品的―ID分组，查询产品数量大于10的ID和产品数量。这个演示样例在Group By子句后使用Where子句查找全部至少有10种产品的类别。
说明：在翻译成SQL 语句时，在最外层嵌套了Where条件。
var categories =
from p in db.Products
group p by new
{
p.CategoryID,
p.SupplierID
}
into g
select new
{
g.Key,
g
};
语句描写叙述：使用Group By按CategoryID和 SupplierID将产品分组。
说明：既按产品的分类，又按供应商分类。在 by后面，new出来一个匿名类。这里，Key事实上质是一个类的对象，Key包括两个 Property：CategoryID、SupplierID。用g.Key.CategoryID能够遍历CategoryID 的值。
var categories =
from p in db.Products
group p by new { Criterion = p.UnitPrice > 10 } into g
select g;
语句描写叙述：使用Group By返回两个产品序列。第一个序列包括单位价格大于10的产品。第二个序列包括单位价格小于或等于10的产品。
说明：按产品单位价格是否大于10分类。其结果分为两类，大于的是一类，小于及等于为还有一类。
适用场景：用于推断集合中元素，进一步缩小范围。
说明：用于推断集合中是否有元素满足某一条件；不延迟。（若条件为空，则集合仅仅要不为空就返回True，否则为 False）。有2种形式，分别为简单形式和带条件形式。
仅返回没有订单的客户：
var q =
from c in db.Customers
where !c.Orders.Any()
select c;
生成SQL语句为：
SELECT [t0].[CustomerID],[t0].[CompanyName], [t0].[ContactName],
[t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region],
[t0].[PostalCode], [t0].[Country],[t0].[Phone], [t0].[Fax]
FROM [dbo].[Customers] AS [t0]
WHERE NOT (EXISTS(
SELECT NULL AS [EMPTY] FROM [dbo].[Orders] AS [t1]
WHERE [t1].[CustomerID] = [t0]. [CustomerID]
))
仅返回至少有一种产品断货的类别：
var q =
from c in db.Categories
where c.Products.Any(p => p.Discontinued)
select c;
生成SQL语句为：
SELECT [t0]. [CategoryID],[t0].[CategoryName], [t0].[Description],
[t0]. [Picture] FROM [dbo].[Categories] AS[t0]
WHERE EXISTS(
SELECT NULL AS [EMPTY] FROM [dbo].[Products] AS [t1]
WHERE ([t1].[Discontinued] = 1) AND
([t1].[CategoryID] = [t0]. [CategoryID])
)
说明：用于推断集合中全部元素是否都满足某一条件；不延迟1.带条件形式
var q =
from c in db.Customers
where c.Orders.All(o => o.ShipCity == c.City)
select c;
语句描写叙述：这个样例返回全部订单都运往其所在城市的客户或未下订单的客户。
说明：用于推断集合中是否包括有某一元素；不延迟。它是对两个序列进行连接操作的。
string[] customerID_Set =
new string[] { "AROUT", "BOLID","FISSA" };
var q = (
from o in db.Orders
where customerID_Set.Contains(o.CustomerID)
select o).ToList ();
语句描写叙述：查找"AROUT", "BOLID" 和 "FISSA" 这三个客户的订单。先定义了一个数组，在LINQ to SQL中使用Contains，数组中包括了全部的CustomerID，即返回结果中，全部的 CustomerID都在这个集合内。也就是in。你也能够把数组的定义放在LINQ to SQL语句里。比方：
var q = (
from o in db.Orders
where (
new string[] { "AROUT", "BOLID","FISSA" })
.Contains (o.CustomerID)
select o).ToList();
Not Contains则取反：
var q = (
from o in db.Orders
where !(
new string[] { "AROUT", "BOLID","FISSA" })
.Contains(o.CustomerID)
select o).ToList();
var order = (from o in db.Orders
where o.OrderID == 10248
select o).First();
var q = db.Customers.Where(p =>p.Orders.Contains(order)).ToList();
foreach (var cust in q)
{
foreach (var ord in cust.Orders)
{
//do something
}
}
语句描写叙述：这个样例使用Contain查找哪个客户包括OrderID为10248的订单。
string[] cities =
new string[] { "Seattle", "London","Vancouver", "Paris" };
var q = db.Customers.Where(p=>cities.Contains(p.City)).ToList();
语句描写叙述：这个样例使用Contains查找其所在城市为西雅图、伦敦、巴黎或温哥华的客户。
适用场景：对两个集合的处理，比如追加、合并、取同样项、相交项等等。
说明：连接不同的集合，不会自己主动过滤同样项；延迟。
var q = (
from c in db.Customers
select c.Phone
).Concat(
from c in db.Customers
select c.Fax
).Concat(
from e in db.Employees
select e.HomePhone
);
语句描写叙述：返回全部消费者和雇员的电话和传真。
var q = (
from c in db.Customers
select new
{
Name = c.CompanyName,
c.Phone
}
).Concat(
from e in db.Employees
select new
{
Name = e.FirstName + " " + e.LastName,
Phone = e.HomePhone
}
);
语句描写叙述：返回全部消费者和雇员的姓名和电话。
说明：连接不同的集合，自己主动过滤同样项；延迟。即是将两个集合进行合并操作，过滤同样的项。
var q = (
from c in db.Customers
select c.Country
).Union(
from e in db.Employees
select e.Country
);
语句描写叙述：查询顾客和职员所在的国家。
说明：取相交项；延迟。即是获取不同集合的同样项（交集）。即先遍历第一个集合，找出全部唯一的元素，然后遍历第二个集合，并将每一个元素与前面找出的元素作对照，返回全部在两个集合内都出现的元素。
var q = (
from c in db.Customers
select c.Country
).Intersect (
from e in db.Employees
select e.Country
);
语句描写叙述：查询顾客和职员同在的国家。
说明：排除相交项；延迟。即是从某集合中删除与还有一个集合中同样的项。先遍历第一个集合，找出全部唯一的元素，然后再遍历第二个集合，返回第二个集合中全部未出如今前面所得元素集合中的元素。
var q = (
from c in db.Customers
select c.Country
).Except(
from e in db.Employees
select e.Country
);
语句描写叙述：查询顾客和职员不同的国家。
适用场景：适量的取出自己想要的数据，不是所有取出，这样性能有所加强。
说明：获取集合的前n个元素；延迟。即仅仅返回限定数量的结果集。
var q = (
from e in db.Employees
orderby e.HireDate
select e)
.Take(5);
语句描写叙述：选择所雇用的前5个雇员。
说明：跳过集合的前n个元素；延迟。即我们跳过给定的数目返回后面的结果集。
var q = (
from p in db.Products
orderby p.UnitPrice descending
select p)
.Skip (10);
语句描写叙述：选择10种最贵产品之外的全部产品。
说明：直到某一条件成立就停止获取；延迟。即用其条件去依次推断源序列中的元素，返回符合推断条件的元素，该推断操作将在返回 false或源序列的末尾结束。
说明：直到某一条件成立就停止跳过；延迟。即用其条件去推断源序列中的元素而且跳过第一个符合推断条件的元素，一旦推断返回false，接下来将不再进行推断并返回剩下的全部元素。
适用场景：结合Skip和Take就可实现对数据分页操作。
var q = (
from c in db.Customers
orderby c.ContactName
select c)
.Skip(50)
.Take(10);
语句描写叙述：使用Skip和Take运算符进行分页，跳过前50条记录，然后返回接下来10条记录，因此提供显示 Products表第6页的数据。
var q = (
from p in db.Products
where p.ProductID > 50
orderby p.ProductID
select p)
.Take(10);
语句描写叙述：使用Where子句和Take运算符进行分页，首先筛选得到仅50 (第5页最后一个ProductID)以上的ProductID，然后按ProductID排序，最后取前10个结果，因此提供Products表第6页的数据。请注意，此方法仅适用于按唯一键排序的情况。
在LINQ to SQL语句中，为我们提供了 SqlMethods操作，进一步为我们提供了方便，比如Like方法用于自己定义通配表达式，Equals用于相比較是否相等。
自己定义的通配表达式。%表示零长度或随意长度的字符串；_表示一个字符；[]表示在某范围区间的一个字符；[^]表示不在某范围区间的一个字符。比方查询消费者ID以“C”开头的消费者。
var q = from c in db.Customers
where SqlMethods.Like(c.CustomerID, "C%")
select c;
比方查询消费者ID没有“AXOXT”形式的消费者：
var q = from c in db.Customers
where ! SqlMethods.Like(c.CustomerID, "A_O_T")
select c;
DateDiffDay
说明：在两个变量之间比較。分别有：DateDiffDay、 DateDiffHour、DateDiffMillisecond、DateDiffMinute、DateDiffMonth、 DateDiffSecond、DateDiffYear
var q = from o in db.Orders
where SqlMethods
.DateDiffDay (o.OrderDate, o.ShippedDate) < 10
select o;
语句描写叙述：查询在创建订单后的 10 天内已发货的全部订单。
说明：在之前我们没有好的方法对写出的SQL语句进行编辑又一次查询，如今我们能够这样做，看以下一个样例：
//1. 创建compiled query
NorthwindDataContext db = newNorthwindDataContext();
var fn = CompiledQuery.Compile(
(NorthwindDataContext db2, string city) =>
from c in db2.Customers
where c.City == city
select c);
//2.查询城市为London的消费者,用LonCusts集合表示，这时能够用数据控件 绑定
var LonCusts = fn(db, "London");
//3.查询城市 为Seattle的消费者
var SeaCusts = fn(db, "Seattle");
语句描写叙述：这个样例创建一个已编译查询，然后使用它检索输入城市的客户。
说明：new一个对象，使用InsertOnSubmit方法将其增加到相应的集合中，使用SubmitChanges()提交到数据库。
NorthwindDataContext db = newNorthwindDataContext();
var newCustomer = new Customer
{
CustomerID = "MCSFT",
CompanyName = "Microsoft",
ContactName = "John Doe",
ContactTitle = "Sales Manager",
Address = "1 Microsoft Way",
City = "Redmond",
Region = "WA",
PostalCode = "98052",
Country = "USA",
Phone = "(425) 555- 1234",
Fax = null
};
db.Customers.InsertOnSubmit(newCustomer);
db.SubmitChanges ();
语句描写叙述：使用InsertOnSubmit方法将新客户加入到Customers 表对象。调用SubmitChanges 将此新Customer保存到数据库。
说明：Category与Product是一对多的关系，提交Category(一端)的数据时，LINQ to SQL会自己主动将Product(多端)的数据一起提交。
var newCategory = new Category
{
CategoryName = "Widgets",
Description = "Widgets are the ……"
};
var newProduct = new Product
{
ProductName = "Blue Widget",
UnitPrice = 34.56M,
Category = newCategory
};
db.Categories.InsertOnSubmit(newCategory);
db.SubmitChanges ();
语句描写叙述：使用InsertOnSubmit方法将新类别加入到Categories 表中，并将新Product对象加入到与此新Category有外键关系的Products表中。调用SubmitChanges将这些新对象及其关系保存到数据库。
说明：在多对多关系中，我们须要依次提交。
var newEmployee = new Employee
{
FirstName = "Kira",
LastName = "Smith"
};
var newTerritory = new Territory
{
TerritoryID = "12345",
TerritoryDescription = "Anytown",
Region = db.Regions.First()
};
var newEmployeeTerritory = newEmployeeTerritory
{
Employee = newEmployee,
Territory = newTerritory
};
db.Employees.InsertOnSubmit(newEmployee);
db.Territories.InsertOnSubmit(newTerritory);
db.EmployeeTerritories.InsertOnSubmit(newEmployeeTerritory);
db.SubmitChanges();
语句描写叙述：使用InsertOnSubmit方法将新雇员加入到Employees 表中，将新Territory加入到Territories表中，并将新 EmployeeTerritory对象加入到与此新Employee对象和新Territory对象有外键关系的EmployeeTerritories表中。调用SubmitChanges将这些新对象及其关系保持到数据库。
说明：CUD就是Create、Update、Delete的缩写。以下的样例就是新建一个ID(主键) 为32的Region，不考虑数据库中有没有ID为32的数据，假设有则替换原来的数据，没有则插入。
Region nwRegion = new Region()
{
RegionID = 32,
RegionDescription = "Rainy"
};
db.Regions.InsertOnSubmit(nwRegion);
db.SubmitChanges ();
语句描写叙述：使用DataContext提供的分部方法InsertRegion插入一个区域。对SubmitChanges 的调用调用InsertRegion 重写，后者使用动态CUD执行Linq To SQL生成的默认SQL查询。
说明：更新操作，先获取对象，进行改动操作之后，直接调用SubmitChanges()方法就可以提交。注意，这里是在同一个DataContext中，对于不同的DataContex看以下的解说。
Customer cust =
db.Customers.First(c => c.CustomerID == "ALFKI");
cust.ContactTitle = "VicePresident";
db.SubmitChanges();
语句描写叙述：使用 SubmitChanges将对检索到的一个Customer对象做出的更新保持回数据库。
var q = from p in db.Products
where p.CategoryID == 1
select p;
foreach (var p in q)
{
p.UnitPrice += 1.00M;
}
db.SubmitChanges ();
语句描写叙述：使用SubmitChanges将对检索到的进行的更新保持回数据库。
说明：调用DeleteOnSubmit方法就可以。
OrderDetail orderDetail =
db.OrderDetails.First
(c => c.OrderID == 10255 && c.ProductID == 36);
db.OrderDetails.DeleteOnSubmit(orderDetail);
db.SubmitChanges();
语句描写叙述：使用 DeleteOnSubmit方法从OrderDetail 表中删除OrderDetail对象。调用 SubmitChanges 将此删除保持到数据库。
说明：Order 与OrderDetail是一对多关系，首先DeleteOnSubmit其OrderDetail(多端)，其次 DeleteOnSubmit其Order(一端)。由于一端是主键。
var orderDetails =
from o in db.OrderDetails
where o.Order.CustomerID == "WARTH" &&
o.Order.EmployeeID == 3
select o;
var order =
(from o in db.Orders
where o.CustomerID == "WARTH" && o.EmployeeID ==3
select o).First();
foreach (OrderDetail od in orderDetails)
{
db.OrderDetails.DeleteOnSubmit(od);
}
db.Orders.DeleteOnSubmit(order);
db.SubmitChanges();
语句描写叙述语句描写叙述：使用DeleteOnSubmit方法从Order 和Order Details表中删除Order和Order Detail对象。首先从Order Details删除，然后从Orders删除。调用SubmitChanges将此删除保持到数据库。
说明：Order与OrderDetail是一对多关系，在上面的样例，我们所有删除CustomerID为WARTH和EmployeeID为3 的数据，那么我们不须所有删除呢？比如Order的OrderID为10248的OrderDetail有非常多，可是我们仅仅要删除 ProductID为11的OrderDetail。这时就用Remove方法。
Order order = db.Orders.First(x =>x.OrderID == 10248);
OrderDetail od =
order.OrderDetails.First(d => d.ProductID == 11);
order.OrderDetails.Remove(od);
db.SubmitChanges();
语句描写叙述语句描写叙述：这个样例说明在实体对象的引用实体将该对象从其EntitySet 中移除时，推理删除怎样导致在该对象上发生实际的删除操作。仅当实体的关联映射将DeleteOnNull设置为true且CanBeNull 为false 时，才会发生推理删除行为。
说明：在对于在不同的 DataContext之间，使用Attach方法来更新数据。比如在一个名为tempdb的 NorthwindDataContext中，查询出Customer和Order，在还有一个 NorthwindDataContext中，Customer的地址更新为123 First Ave，Order的 CustomerID 更新为CHOPS。
//通常，通过从其它层反序列化 XML 来获取要附加的实体
//不支持将实体从一个DataContext附加到还有一个DataContext
//因此若要复制反序列化实体的操作，将在此处又一次创建这 些实体
Customer c1;
List<Order> deserializedOrders = newList<Order>();
Customer deserializedC1;
using (NorthwindDataContext tempdb = newNorthwindDataContext())
{
c1 = tempdb.Customers.Single(c => c.CustomerID =="ALFKI");
deserializedC1 = new Customer
{
Address = c1.Address,
City = c1.City,
CompanyName = c1.CompanyName,
ContactName = c1.ContactName,
ContactTitle = c1.ContactTitle,
Country = c1.Country,
CustomerID = c1.CustomerID,
Fax = c1.Fax,
Phone = c1.Phone,
PostalCode = c1.PostalCode,
Region = c1.Region
};
Customer tempcust =
tempdb.Customers.Single(c => c.CustomerID == "ANTON");
foreach (Order o in tempcust.Orders)
{
deserializedOrders.Add(new Order
{
CustomerID = o.CustomerID,
EmployeeID = o.EmployeeID,
Freight = o.Freight,
OrderDate = o.OrderDate,
OrderID = o.OrderID,
RequiredDate = o.RequiredDate,
ShipAddress = o.ShipAddress,
ShipCity = o.ShipCity,
ShipName = o.ShipName,
ShipCountry = o.ShipCountry,
ShippedDate = o.ShippedDate,
ShipPostalCode = o.ShipPostalCode,
ShipRegion = o.ShipRegion,
ShipVia = o.ShipVia
});
}
}
using (NorthwindDataContext db2 = newNorthwindDataContext())
{
//将第一个实体附加到当前数据上下文，以跟踪更改
//对Customer更新，不能写错
db2.Customers.Attach(deserializedC1);
//更改所跟踪的实体
deserializedC1.Address = "123 First Ave";
// 附加订单列表中的全部实体
db2.Orders.AttachAll (deserializedOrders);
//将订单更新为属于其它客户
foreach (Order o in deserializedOrders)
{
o.CustomerID = "CHOPS";
}
//在当前数据上下文中提交更改
db2.SubmitChanges();
}
语句描写叙述：从还有一个层中获取实体，使用Attach和AttachAll将反序列化后的实体附加到数据上下文，然后更新实体。更改被提交到数据库。
使用Attach更新和删除(Update and Delete with Attach)
说明：在不同的DataContext中，实现插入、更新、删除。看以下的一个样例：
//通常，通过从其它层 反序列化XML获取要附加的实体
//此演示样例使用 LoadWith 在一个查询中预 先载入客户和订单，
//并禁用延迟载入
Customer cust = null;
using (NorthwindDataContext tempdb = newNorthwindDataContext())
{
DataLoadOptions shape = new DataLoadOptions();
shape.LoadWith<Customer>(c => c.Orders);
//载入第一个客户实体及其订单
tempdb.LoadOptions = shape;
tempdb.DeferredLoadingEnabled = false;
cust = tempdb.Customers.First(x => x.CustomerID =="ALFKI");
}
Order orderA = cust.Orders.First();
Order orderB = cust.Orders.First(x =>x.OrderID > orderA.OrderID);
using (NorthwindDataContext db2 = newNorthwindDataContext())
{
//将第一个实体附加到当前数据上下文，以跟踪更改
db2.Customers.Attach(cust);
//附加相关订单以进行跟踪; 否则将在提交时插入它们
db2.Orders.AttachAll(cust.Orders.ToList ());
//更新客户的Phone.
cust.Phone = "2345 5436";
//更新第一个订单OrderA的ShipCity.
orderA.ShipCity = "Redmond";
//移除第二个订单 OrderB.
cust.Orders.Remove(orderB);
//加入一个新的订单Order到客户Customer中.
Order orderC = new Order() { ShipCity = "New York" };
cust.Orders.Add (orderC);
//提交运行
db2.SubmitChanges();
}
语句描写叙述：从一个上下文提取实体，并使用 Attach 和 AttachAll 附加来自其它上下文的实体，然后更新这两个实体，删除一个实体，加入还有一个实体。更改被提交到数据库。
下表介绍 LINQ to SQL 文档中涉及开放式并发的术语：
术语说明
并发两个或很多其它用户同一时候尝试更新同一数据库行的情形。
并发冲突两个或很多其它用户同一时候尝试向一行的一列或多列提交冲突值的情形。
并发控制用于解决并发冲突的技术。
开放式并发控制先调查其它事务是否已更改了行中的值，再同意提交更改的技术。相比之下，保守式并发控制则是通过锁定记录来避免发生并发冲突。之所以称作开放式控制，是由于它将一个事务干扰还有一事务视为不太可能发生。
冲突解决通过又一次查询数据库刷新出现冲突的项，然后协调差异的过程。刷新对象时，LINQ to SQL 更改跟踪器会保留下面数据：最初从数据库获取并用于更新检查的值通过兴许查询获得的新数据库值。 LINQ to SQL 随后会确定对应对象是否发生冲突（即它的一个或多个成员值是否已发生更改）。假设此对象发生冲突，LINQ to SQL 下一步会确定它的哪些成员发生冲突。LINQ to SQL 发现的不论什么成员冲突都会加入到冲突列表中。
在 LINQ to SQL 对象模型中，当下面两个条件都得到满足时，就会发生“开放式并发冲突”：client尝试向数据库提交更改；数据库中的一个或多个更新检查值自client上次读取它们以来已得到更新。此冲突的解决过程包含查明对象的哪些成员发生冲突，然后决定您希望怎样进行处理。
说明：这个样例中在你读取数据之前，另外一个用户已经改动并提交更新了这个数据，所以不会出现冲突。
//我们打开一个新的连接来模拟另外一个用户
NorthwindDataContext otherUser_db = newNorthwindDataContext();
var otherUser_product =
otherUser_db.Products.First(p => p.ProductID == 1);
otherUser_product.UnitPrice = 999.99M;
otherUser_db.SubmitChanges();
//我们当前连接
var product = db.Products.First(p =>p.ProductID == 1);
product.UnitPrice = 777.77M;
try
{
db.SubmitChanges();//当前连接运行成功
}
catch (ChangeConflictException)
{
}
说明：我们读取数据之后，另外一个用户获取并提交更新了这个数据，这时，我们更新这个数据时，引起了一个并发冲突。系统发生回滚，同意你能够从数据库检索新更新的数据，并决定怎样继续进行您自己的更新。
//当前 用户
var product = db.Products.First(p =>p.ProductID == 1);
//我们打开一个新的连接来模拟另外一个用户
NorthwindDataContext otherUser_db = newNorthwindDataContext() ;
var otherUser_product =
otherUser_db.Products.First(p => p.ProductID == 1);
otherUser_product.UnitPrice = 999.99M;
otherUser_db.SubmitChanges();
//当前用户改动
product.UnitPrice = 777.77M;
try
{
db.SubmitChanges();
}
catch (ChangeConflictException)
{
//发生异常！
}
Transactions事务
LINQto SQL 支持三种事务模型，各自是：
显式本地事务：调用 SubmitChanges 时，假设 Transaction 属性设置为事务，则在同一事务的上下文中运行 SubmitChanges 调用。成功运行事务后，要由您来提交或回滚事务。与事务相应的连接必须与用于构造 DataContext 的连接匹配。假设使用其它连接，则会引发异常。
显式可分发事务：能够在当前 Transaction 的作用域中调用 LINQ to SQL API（包含但不限于 SubmitChanges）。LINQ to SQL 检測到调用是在事务的作用域内，因而不会创建新的事务。在这样的情况下， <token>vbtecdlinq</token> 还会避免关闭连接。您能够在此类事 务的上下文中运行查询和SubmitChanges 操作。
隐式事务：当您调用 SubmitChanges 时，LINQ to SQL 会检查此调用是否在 Transaction 的作用域内或者 Transaction 属性是否设置为由用户启动的本地事务。假设这两个事务它均未找到，则 LINQ to SQL 启动本地事务，并使用此事务运行所生成的 SQL 命令。当全部 SQL 命令均已成功运行完成时，LINQ to SQL 提交本地事务并返回。
说明：这个样例在运行SubmitChanges ()操作时，隐式地使用了事务。由于在更新2种产品的库存数量时，第二个产品库存数量为负数了,违反了server上的 CHECK 约束。这导致了更新产品所有失败了，系统回滚到这个操作的初始状态。
try
{
Product prod1 = db.Products.First(p => p.ProductID == 4);
Product prod2 = db.Products.First(p => p.ProductID == 5);
prod1.UnitsInStock -= 3;
prod2.UnitsInStock -= 5;//错误:库存 数量的单位不能是负数
//要么所有成功要么所有失败
db.SubmitChanges();
}
catch (System.Data.SqlClient.SqlExceptione)
{
//运行异常处理
}
说明：这个样例使用显式事务。通过在事务中增加对数据的读取以防止出现开放式并发异常，显式事务能够提供很多其它的保护。如同上一个查询中，更新 prod2 的 UnitsInStock 字段将使该字段为负值，而这违反了数据库中的 CHECK 约束。这导致更新这两个产品的事务失败，此时将回滚全部更改。
using (TransactionScope ts = new TransactionScope())
{
try
{
Product prod1 = db.Products.First(p => p.ProductID == 4);
Product prod2 = db.Products.First(p => p.ProductID == 5);
prod1.UnitsInStock -= 3;
prod2.UnitsInStock -= 5;//错误:库存数量的单位不能是负数
db.SubmitChanges();
}
catch (System.Data.SqlClient.SqlException e)
{
//运行异常处理
}
}
说明：以下第一个样例说明查询ReportsToEmployee为null的雇员。第二个样例使用Nullable<T>.HasValue查询雇员，其结果与第一个例 子同样。在第三个样例中，使用Nullable<T>.Value来返回ReportsToEmployee不为null的雇员的ReportsTo的值。
查找不隶属于还有一个雇员的全部雇员：
var q =
from e in db.Employees
where e.ReportsToEmployee == null
select e;
查找不隶属于还有一个雇员的全部雇员：
var q =
from e in db.Employees
where !e.ReportsTo.HasValue
select e;
3.Nullable<T>.Value
返回前者的EmployeeID 编号。请注意 .Value 为可选：
var q =
from e in db.Employees
where e.ReportsTo.HasValue
select new
{
e.FirstName,
e.LastName,
ReportsTo = e.ReportsTo.Value
};
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 或固定时间要自己运行转换。
以下用三个实例说明一下。
var q =
from o in db.Orders
where o.OrderDate.Value.Year == 1997
select o;
语句描写叙述：这个样例使用DateTime 的Year 属性查找1997 年下的订单。
var q =
from o in db.Orders
where o.OrderDate.Value.Month == 12
select o;
语句描写叙述：这个样例使用DateTime的Month属性查找十二月下的订单。
var q =
from o in db.Orders
where o.OrderDate.Value.Day == 31
select o;
语句描写叙述：这个样例使用DateTime的Day属性查找某月 31 日下的订单。
LINQ to SQL支持下面String方法。可是不同的是默认 情况下System.String方法区分大写和小写。而SQL则不区分大写和小写。
var q =
from c in db.Customers
select new
{
c.CustomerID,
Location = c.City + ", " + c.Country
};
语句描写叙述：这个样例使用+运算符在形成经计算得出的客户Location值过程中将字符串字段和字符串串联在一起。
var q =
from p in db.Products
where p.ProductName.Length < 10
select p;
语句描写叙述：这个样例使用Length属性查找名称短于10个字符的全部产品。
var q =
from c in db.Customers
where c.ContactName.Contains ("Anders")
select c;
语句描写叙述：这个样例使用Contains方法查找全部其联系人姓名中包括“Anders”的客户。
var q =
from c in db.Customers
select new
{
c.ContactName,
SpacePos = c.ContactName.IndexOf(" ")
};
语句描写叙述：这个样例使用IndexOf方法查找每一个客户联系人姓名中出现第一个空格的位置。
var q =
from c in db.Customers
where c.ContactName.StartsWith("Maria")
select c;
语句描写叙述：这个样例使用StartsWith方法查找联系人姓名以“Maria”开头的客户。
var q =
from c in db.Customers
where c.ContactName.EndsWith("Anders")
select c;
语句描写叙述：这个样例使用EndsWith方法查找联系人姓名以“Anders”结尾的客户。
var q =
from p in db.Products
select p.ProductName.Substring(3);
语句描写叙述：这个样例使用Substring方法返回产品名称中从第四个字母開始的部分。
var q =
from e in db.Employees
where e.HomePhone.Substring(6, 3) == "555"
select e;
语句描写叙述：这个样例使用Substring方法查找家庭电话号码第七位到第九位是“555”的雇员。
var q =
from e in db.Employees
select new
{
LastName = e.LastName.ToUpper(),
e.FirstName
};
语句描写叙述：这个样例使用ToUpper方法返回姓氏已转换为大写的雇员姓名。
var q =
from c in db.Categories
select c.CategoryName.ToLower();
语句描写叙述：这个样例使用ToLower方法返回已转换为小写的类别名称。
var q =
from e in db.Employees
select e.HomePhone.Substring(0, 5).Trim ();
语句描写叙述：这个样例使用Trim方法返回雇员家庭电话号码的前五位，并移除前导和跟随空格。
var q =
from e in db.Employees
where e.HomePhone.Substring(4, 1) == ")"
select e.HomePhone.Insert(5, ":");
语句描写叙述：这个样例使用 Insert方法返回第五位为 ) 的雇员电话号码的序列，并在 ) 后面插入一个 :。
var q =
from e in db.Employees
where e.HomePhone.Substring(4, 1) == ") "
select e.HomePhone.Remove(9);
语句描写叙述：这个样例使用Remove方法返回第五位为 ) 的雇员电话号码的序列，并移除从第十个字符開始的全部字符。
var q =
from e in db.Employees
where e.HomePhone.Substring(4, 1) == ")"
select e.HomePhone.Remove(0, 6);
语句描写叙述：这个样例使用Remove方法返回第五位为 ) 的雇员电话号码的序列，并移除前六个字符。
var q =
from s in db.Suppliers
select new
{
s.CompanyName,
Country = s.Country
.Replace ("UK", "United Kingdom")
.Replace ("USA", "United States of America")
};
语句描写叙述：这个样例使用 Replace 方法返回 Country 字段中UK 被替换为 United Kingdom 以及USA 被替换为 United States of America 的供 应商信息。
执行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后，能够通过还有一个变量看到这些更改。
关系数据库表中的行不具有唯一标识。因为每一行都具有唯一的主键，因此不论什么两行都不会共用同一键值。
实际上，通常我们是将数据从数据库中提取出来放入还有一层中，应用程序在该层对数据进行处理。这就是 LINQ to SQL 支持的模型。将数据作为行从数据库中提取出来时，你不期望表示同样数据的两行实际上相应于同样的行实例。假设您查询特定客户两次，您将获得两行数据。每一行包括同样的信息。
对于对象。你期望在你重复向 DataContext 索取同样的信息时，它实际上会为你提供同一对象实例。你将它们设计为层次结构或关系图。你希望像检索实物一样检索它们，而不希望只由于你多次索要同一内容而收到大量的复制实例。
在 LINQ to SQL 中， DataContext 管理对象标识。仅仅要你从数据库中检索新行，该行就会由其主键记录到标识表中，而且会创建一个新的对象。仅仅要您检索该行，就会将原始对象实例传递回应用程序。通过这样的方式，DataContext 将数据库看到的标识（即主键）的概念转换成对应语言看到的标识（即实例）的概念。应用程序仅仅看到处于第一次检索时的状态的对象。新数据假设不同，则会被丢弃。
LINQ to SQL 使用此方法来管理本地对象的完整性，以支持开放式更新。因为在最初创建对象 后唯一发生的更改是由应用程序做出的，因此应用程序的意向是非常明白的。假设在中间阶段外部某一方做了更改，则在调用 SubmitChanges() 时会识别出这些更改。
以上来自MSDN，的确，看了有点“正规”，以下我用两个样例说明一下。
在第一个演示样例中，假设我们运行同一查询两次，则每次都会收到对内存中同一对象的引用。非常明显，cust1和cust2是同一个对象引用。
Customer cust1 = db.Customers.First(c =>c.CustomerID == "BONAP");
Customer cust2 = db.Customers.First(c =>c.CustomerID == "BONAP");
以下的演示样例中，假设您运行返回数据库中同一行的不同查询，则您每次都会收到对内存中同一对象的引用。cust1和cust2是同一个对象引用，可是数据库查询了两次。
Customer cust1 = db.Customers.First(c =>c.CustomerID == "BONAP");
Customer cust2 = (
from o in db.Orders
where o.Customer.CustomerID == "BONAP"
select o )
.First()
.Customer;
在查询某对象时，实际上你仅仅查询该对象。不会同一时候自己主动获取这个对象。这就是延迟载入。
比如，您可能须要查看客户数据和订单数据。你最初不一定须要检索与每一个客户有关的全部订单数据。其长处是你能够使用延迟载入将额外信息的检索操作延迟到你确实须要检索它们时再进行。请看以下的演示样例：检索出来CustomerID，就依据这个ID查询出OrderID。
var custs =
from c in db.Customers
where c.City == "Sao Paulo"
select c;
//上面 的查询句法不会导致语句马上运行,不过一个描写叙述性的语句,
仅仅有须要的时候才会运行它
foreach (var cust in custs)
{
foreach (var ord in cust.Orders)
{
//同一时候查看客户数据和订单数据
}
}
语句描写叙述：原始查询未请求数据，在所检索到各个对象的链接中导航怎样能导致触发对数据库的新查询。
你假设想要同一时候查询出一些对象的集合的方法。LINQ to SQL 提供了 DataLoadOptions用于马上载入对象。方法包含：
LoadWith 方法，用于马上载入与主目标相关的数据。
AssociateWith 方法，用于筛选为特定关系检索到的对象。
使用 LoadWith方法指定应同一时候检索与主目标相关的哪些数据。比如，假设你知道你须要有关客户的订单的信息，则能够使用 LoadWith 来确保在检索客户信息的同一时候检索订单信息。使用此方法可仅訪问一次数据库，但同一时候获取两组信息。
在以下的演示样例中，我们通过设置DataLoadOptions，来指示DataContext 在载入Customers的同一时候把相应的Orders一起载入，在运行查询时会检索位于Sao Paulo的全部 Customers 的全部 Orders。这样一来，连续訪问 Customer 对象的 Orders 属性不会触发新的数据库查询。在运行时生成的SQL语句使用了左连接。
NorthwindDataContext db = newNorthwindDataContext ();
DataLoadOptions ds = new DataLoadOptions();
ds.LoadWith<Customer>(p =>p.Orders);
db.LoadOptions = ds;
var custs = (
from c in db2.Customers
where c.City == "Sao Paulo"
select c);
foreach (var cust in custs)
{
foreach (var ord in cust.Orders)
{
Console.WriteLine ("CustomerID {0} has an OrderID {1}.",
cust.CustomerID,
ord.OrderID);
}
}
语句描写叙述：在原始查询过程中使用 LoadWith 请求相关数据，以便稍后在检索到的各个对象中导航时不须要对数据库进行额外的往返。
运算符转换
使用 AsEnumerable<TSource> 可返回类型化为泛型 IEnumerable的參数。在 此演示样例中，LINQ toSQL（使用默认泛型 Query）会尝试将查询转换为 SQL 并在server上运行。但 where 子句引用用户定义的client方法 (isValidProduct)，此方法无法转换为 SQL。
解决方法是指定 where 的client泛型 IEnumerable<T> 实现以替换泛型 IQueryable<T>。可通过调用 AsEnumerable<TSource>运算符来运行此操作。
var q =
from p in db.Products.AsEnumerable()
where isValidProduct(p)
select p;
语句描写叙述：这个样例就是使用AsEnumerable以便使用Where的clientIEnumerable实现，而不是默认的 IQueryable将在server上转换为SQL并运行的默认Query<T>实现。这非常有必要，由于Where子句引用了用户定义的client方法isValidProduct，该方法不能转换为SQL。
使用 ToArray <TSource>可从序列创建数组。
var q =
from c in db.Customers
where c.City == "London"
select c;
Customer[] qArray = q.ToArray();
语句描写叙述：这个样例使用 ToArray 将查询直接计算为数组。
使用 ToList<TSource>可从序列创建泛型列表。以下的演示样例使用 ToList<TSource>直接将查询的计算结果放入泛型 List<T>。
var q =
from e in db.Employees
where e.HireDate >= new DateTime(1994, 1, 1)
select e;
List<Employee> qList = q.ToList();
使用Enumerable.ToDictionary<TSource, TKey>方法可 以将序列转化为字典。TSource表示source中的元素的类型；TKey表示keySelector返回的键的类型。其返回一个包括键和值的Dictionary<TKey, TValue>。
var q =
from p in db.Products
where p.UnitsInStock <= p.ReorderLevel && ! p.Discontinued
select p;
Dictionary<int, Product> qDictionary=
q.ToDictionary(p => p.ProductID);
foreach (int key in qDictionary.Keys)
{
Console.WriteLine(key);
}
语句描写叙述：这个样例使用 ToDictionary 将查询和键表达式直接键表达式直接计算为 Dictionary<K, T>。
ADO.NET与LINQ to SQL
它基于由 ADO.NET 提供程序模型提供的服务。因此，我们能够将 LINQ to SQL 代码与现有的 ADO.NET 应用程序混合在一起，将当前 ADO.NET 解决方式迁移到 LINQ to SQL。
在创建 LINQ to SQL DataContext 时，能够提供现有 ADO.NET 连接。对DataContext 的全部操作（包含查询）都使用所提供的这个连接。假设此连接已经打开，则在您使用完此连接时，LINQ to SQL 会保持它的打开状态不变。我们始终能够訪问此连接，另外还能够使用 Connection 属性自行关闭它。
//新建一个 标准的ADO.NET连接:
SqlConnection nwindConn = new SqlConnection(connString);
nwindConn.Open();
// ... 其他的ADO.NET数据操作 代码... //
//利用现有的ADO.NET连接来创建一个DataContext:
Northwind interop_db = new Northwind(nwindConn);
var orders =
from o in interop_db.Orders
where o.Freight > 500.00M
select o;
//返回Freight>500.00M的订单
nwindConn.Close();
语句描写叙述：这个样例使用预先存在的ADO.NET 连接创建Northwind对象，本例中的查询返回运费至少为500.00 的全部订单。
当我们已经启动了自己的数据库事务而且我们希望 DataContext 包括在内时，我们能够向 DataContext 提供此事务。
通过 .NET Framework 创建事务的首选方法是使用 TransactionScope 对象。通过使用此方法，我们能够创建跨数据库及其它驻留在内存中的资源管理器运行的分布式事务。事务范围差点儿不须要资源就能够启动。它们仅在事务范围内存在多个连接时才将自身提升为分布式事务。
using (TransactionScope ts = newTransactionScope())
{
db.SubmitChanges();
ts.Complete();
}
注意：不能将此方法用于全部数据库。比如，SqlClient 连接在针对 SQL Server 2000 server使用时无法提升系统事务。它採取的方法是，仅仅要它发现有使用事务范围的情况，它就会自己主动向完整的分布式事务登记。
以下用一个样例说明一下事务的用法。在这里，也说明了重用 ADO.NET 命令和 DataContext 之间的同一连接。
var q =
from p in db.Products
where p.ProductID == 3
select p;
//使用LINQ to SQL查询出来
//新建一个标准的ADO.NET连接:
SqlConnection nwindConn = newSqlConnection(connString);
nwindConn.Open();
//利用现有的 ADO.NET连接来创建一个DataContext:
Northwind interop_db = newNorthwind(nwindConn);
SqlTransaction nwindTxn =nwindConn.BeginTransaction();
try
{
SqlCommand cmd = new SqlCommand("UPDATE Products SET"
+"QuantityPerUnit = ‘single item‘ WHERE ProductID = 3");
cmd.Connection = nwindConn;
cmd.Transaction = nwindTxn;
cmd.ExecuteNonQuery();
interop_db.Transaction = nwindTxn;
Product prod1 = interop_db.Products.First(p => p.ProductID == 4);
Product prod2 = interop_db.Products.First(p => p.ProductID == 5);
prod1.UnitsInStock -= 3;
prod2.UnitsInStock -= 5;//这有一个错 误，不能为负数
interop_db.SubmitChanges();
nwindTxn.Commit();
}
catch (Exception e)
{
// 假设有一个错误，全部的操作回滚
Console.WriteLine (e.Message);
}
nwindConn.Close();
语句描写叙述：这个样例使用预先存在的 ADO.NET 连接创建 Northwind 对象，然后与此对象共享一个 ADO.NET 事务。此事务既用于通过 ADO.NET 连接运行 SQL 命令，又用于通过 Northwind 对象提交更改。当事务因违反 CHECK 约束而中止时，将回滚全部更改，包含通过 SqlCommand 做出的更改，以及通过Northwind 对象做出的更改。
存储过程
在我们编敲代码中，往往须要一些存储过程，在LINQ to SQL中怎么使用呢？或许比原来的更简单些。以下我们以NORTHWND.MDF数据库中自带的几个存储过程来理解一下。
在数据库中，有名为 Customers Count By Region的存储过程。该存储过程返回想客所在"WA"区域的数量。
ALTER PROCEDURE [dbo]. [NonRowset]
(@param1 NVARCHAR(15))
AS
BEGIN
SET NOCOUNT ON;
DECLARE @count int
SELECT @count = COUNT(*)FROM Customers
WHERECustomers.Region = @Param1
RETURN @count
END
我们仅仅要把这个存储过程拖到O/R设计器内，它自己主动生成了下面代码段：
[Function(Name = "dbo.[Customers CountBy Region]")]
public intCustomers_Count_By_Region([Parameter
(DbType = "NVarChar (15)")]string param1)
{
IExecuteResult result = this.ExecuteMethodCall(this,
((MethodInfo) (MethodInfo.GetCurrentMethod())), param1);
return ((int) (result.ReturnValue));
}
我们须要时，直接调用就能够了，比如：
int count = db.CustomersCountByRegion("WA");
Console.WriteLine(count);
语句描写叙述：这个实例使用存储过程返回在“WA”地区的客户数。
从数据库中返回行集合，并包括用于筛选结果的输入參数。当我们运行 返回行集合的存储过程时，会用到结果类，它存储从存储过程中返回的结果。
以下的演示样例表示一个存储过程，该存储过程返回客户行并使用输入參数来仅返回将“London”列为客户城市的那些行的固定几列。
ALTER PROCEDURE [dbo].[Customers By City]
-- Add the parameters for the stored procedure here
(@param1 NVARCHAR(20))
AS
BEGIN
-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON;
SELECT CustomerID, ContactName, CompanyName, City from
Customers as c where c.City=@param1
END
拖到O/R设计器内，它自己主动生成了下面代码段：
[Function(Name="dbo.[Customers ByCity]")]
publicISingleResult<Customers_By_CityResult> Customers_By_City(
[Parameter(DbType="NVarChar(20)")]string param1)
{
IExecuteResult result = this.ExecuteMethodCall(this, (
(MethodInfo) (MethodInfo.GetCurrentMethod())), param1);
return ((ISingleResult<Customers_By_CityResult>)
(result.ReturnValue));
}
我们用以下的代码调用：
ISingleResult<Customers_By_CityResult>result =
db.Customers_By_City("London");
foreach (Customers_By_CityResult cust inresult)
{
Console.WriteLine("CustID={0}; City={1}",cust.CustomerID,
cust.City);
}
语句描写叙述：这个实例使用存储过程返回在伦敦的客户的 CustomerID和City。
当存储过程能够返回多个结果形状时，返回类型无法强类型化为单个投影形状。虽然 LINQ to SQL 能够生成全部可能的投影类型，但它无法获知将以何种顺序返回它们。 ResultTypeAttribute 属性适用于返回多个结果类型的存储过程，用以指定该过程能够返回的类型的集合。
在以下的 SQL 代码演示样例中，结果形状取决于输入（param1 = 1或param1 = 2）。我们不知道先返回哪个投影。
ALTER PROCEDURE [dbo].[SingleRowset_MultiShape]
-- Add the parameters for the stored procedure here
(@param1 int )
AS
BEGIN
-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON;
if(@param1 = 1)
SELECT * from Customers as c where c.Region = ‘WA‘
else if (@param1 = 2)
SELECT CustomerID, ContactName, CompanyName from
Customers as c where c.Region = ‘WA‘
END
拖到O/R 设计器内，它自己主动生成了下面代码段：
[Function (Name="dbo.[Whole Or PartialCustomers Set]")]
publicISingleResult<Whole_Or_Partial_Customers_SetResult>
Whole_Or_Partial_Customers_Set([Parameter(DbType="Int")]
System.Nullable<int> param1)
{
IExecuteResult result = this.ExecuteMethodCall(this,
((MethodInfo)(MethodInfo.GetCurrentMethod())), param1);
return ((ISingleResult<Whole_Or_Partial_Customers_SetResult>)
(result.ReturnValue));
}
可是，VS2008会把多结果集存储过程识别为单结果集的存储过程，默认生成的代码我们要手动改动一下，要求返回多个结果集，像这样：
[Function(Name="dbo.[Whole Or PartialCustomers Set]")]
[ResultType(typeof (WholeCustomersSetResult))]
[ResultType(typeof(PartialCustomersSetResult))]
public IMultipleResultsWhole_Or_Partial_Customers_Set([Parameter
(DbType="Int")]System.Nullable<int> param1)
{
IExecuteResult result = this.ExecuteMethodCall(this,
((MethodInfo)(MethodInfo.GetCurrentMethod())), param1);
return ((IMultipleResults)(result.ReturnValue));
}
我们分别定义了两个分部类，用于指定返回的类型。WholeCustomersSetResult类 如 下：
public partial classWholeCustomersSetResult
{
private string _CustomerID;
private string _CompanyName;
private string _ContactName;
private string _ContactTitle;
private string _Address;
private string _City;
private string _Region;
private string _PostalCode;
private string _Country;
private string _Phone;
private string _Fax;
public WholeCustomersSetResult()
{
}
[Column (Storage = "_CustomerID", DbType ="NChar(5)")]
public string CustomerID
{
get { return this._CustomerID; }
set
{
if ((this._CustomerID != value))
this._CustomerID = value;
}
}
[Column(Storage = "_CompanyName", DbType ="NVarChar(40)")]
public string CompanyName
{
get { return this._CompanyName; }
set
{
if ((this._CompanyName != value))
this._CompanyName = value;
}
}
[Column (Storage = "_ContactName", DbType ="NVarChar(30) ")]
public string ContactName
{
get { return this._ContactName; }
set
{
if ((this._ContactName != value))
this._ContactName = value;
}
}
[Column (Storage = "_ContactTitle", DbType ="NVarChar(30) ")]
public string ContactTitle
{
get { return this._ContactTitle; }
set
{
if ((this._ContactTitle != value))
this._ContactTitle = value;
}
}
[Column(Storage = "_Address", DbType = "NVarChar(60)")]
public string Address
{
get { return this._Address; }
set
{
if ((this._Address != value))
this._Address = value;
}
}
[Column(Storage = "_City", DbType = "NVarChar(15)")]
public string City
{
get { return this._City; }
set
{
if ((this._City != value))
this._City = value;
}
}
[Column(Storage = "_Region", DbType = "NVarChar(15)")]
public string Region
{
get { return this._Region; }
set
{
if ((this._Region != value))
this._Region = value;
}
}
[Column(Storage = "_PostalCode", DbType ="NVarChar(10)")]
public string PostalCode
{
get { return this._PostalCode; }
set
{
if ((this._PostalCode != value))
this._PostalCode = value;
}
}
[Column(Storage = "_Country", DbType ="NVarChar(15)")]
public string Country
{
get { return this._Country; }
set
{
if ((this._Country != value))
this._Country = value;
}
}
[Column(Storage = "_Phone", DbType ="NVarChar(24)")]
public string Phone
{
get { return this._Phone; }
set
{
if ((this._Phone != value))
this._Phone = value;
}
}
[Column(Storage = "_Fax", DbType ="NVarChar(24)")]
public string Fax
{
get { return this._Fax; }
set
{
if ((this._Fax != value))
this._Fax = value;
}
}
}
PartialCustomersSetResult类 例如以下：
public partial classPartialCustomersSetResult
{
private string _CustomerID;
private string _ContactName;
private string _CompanyName;
public PartialCustomersSetResult()
{
}
[Column (Storage = "_CustomerID", DbType ="NChar(5)")]
public string CustomerID
{
get { return this._CustomerID; }
set
{
if ((this._CustomerID != value))
this._CustomerID = value;
}
}
[Column(Storage = "_ContactName", DbType ="NVarChar(30)")]
public string ContactName
{
get { return this._ContactName; }
set
{
if ((this._ContactName != value))
this._ContactName = value;
}
}
[Column (Storage = "_CompanyName", DbType ="NVarChar(40) ")]
public string CompanyName
{
get { return this._CompanyName; }
set
{
if ((this._CompanyName != value))
this._CompanyName = value;
}
}
}
这样就能够使用了，以下代码直接调用，分别返回各自的结果集合。
//返回所有Customer结果集
IMultipleResults result =db.Whole_Or_Partial_Customers_Set(1);
IEnumerable<WholeCustomersSetResult>shape1 =
result.GetResult<WholeCustomersSetResult>();
foreach (WholeCustomersSetResult compNamein shape1)
{
Console.WriteLine(compName.CompanyName);
}
//返回部分 Customer结果集
result =db.Whole_Or_Partial_Customers_Set(2);
IEnumerable<PartialCustomersSetResult>shape2 =
result.GetResult<PartialCustomersSetResult>();
foreach (PartialCustomersSetResult con inshape2)
{
Console.WriteLine(con.ContactName);
}
语句描写叙述：这个实例使用存储过程返回“WA”地区中的一组客户。返回的结果集形状取决于传入的參数。假设參数等于 1，则返回全部客户属性。假设參数等于2，则返回ContactName属性。
这样的存储过程能够生成多个结果形状，但我们已经知道结果的返回顺序。
以下是一个按顺序返回多个结果集的存储过程Get Customer And Orders。 返回想客ID为"SEVES"的顾客和他们全部的订单。
ALTER PROCEDURE [dbo].[Get Customer AndOrders]
(@CustomerID nchar(5))
-- Add the parameters for the stored procedure here
AS
BEGIN
-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON;
SELECT * FROM Customers AS c WHERE c.CustomerID = @CustomerID
SELECT * FROM Orders AS o WHERE o.CustomerID = @CustomerID
END
拖到设计器代码例如以下：
[Function (Name="dbo.[Get Customer AndOrders]")]
publicISingleResult<Get_Customer_And_OrdersResult>
Get_Customer_And_Orders([Parameter(Name="CustomerID",
DbType="NChar(5)")] stringcustomerID)
{
IExecuteResult result = this.ExecuteMethodCall(this,
((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID);
return ((ISingleResult<Get_Customer_And_OrdersResult>)
(result.ReturnValue));
}
相同，我们要改动自己主动生成的代码：
[Function(Name="dbo.[Get Customer AndOrders] ")]
[ResultType(typeof(CustomerResultSet))]
[ResultType(typeof(OrdersResultSet))]
public IMultipleResultsGet_Customer_And_Orders
([Parameter(Name="CustomerID",DbType="NChar(5)")]
string customerID)
{
IExecuteResult result = this.ExecuteMethodCall(this,
((MethodInfo) (MethodInfo.GetCurrentMethod())), customerID);
return ((IMultipleResults)(result.ReturnValue));
}
相同，自己手写类，让其存储过程返回各自的结果集。
CustomerResultSet类
public partial class CustomerResultSet
{
private string _CustomerID;
private string _CompanyName;
private string _ContactName;
private string _ContactTitle;
private string _Address;
private string _City;
private string _Region;
private string _PostalCode;
private string _Country;
private string _Phone;
private string _Fax;
public CustomerResultSet()
{
}
[Column(Storage = "_CustomerID", DbType ="NChar(5)")]
public string CustomerID
{
get { return this._CustomerID; }
set
{
if ((this._CustomerID != value))
this._CustomerID = value;
}
}
[Column(Storage = "_CompanyName", DbType ="NVarChar(40)")]
public string CompanyName
{
get { return this._CompanyName; }
set
{
if ((this._CompanyName != value))
this._CompanyName = value;
}
}
[Column (Storage = "_ContactName", DbType ="NVarChar(30) ")]
public string ContactName
{
get { return this._ContactName; }
set
{
if ((this._ContactName != value))
this._ContactName = value;
}
}
[Column (Storage = "_ContactTitle", DbType ="NVarChar(30) ")]
public string ContactTitle
{
get { return this._ContactTitle; }
set
{
if ((this._ContactTitle != value))
this._ContactTitle = value;
}
}
[Column(Storage = "_Address", DbType = "NVarChar(60)")]
public string Address
{
get { return this._Address; }
set
{
if ((this._Address != value))
this._Address = value;
}
}
[Column(Storage = "_City", DbType ="NVarChar(15)")]
public string City
{
get { return this._City; }
set
{
if ((this._City != value))
this._City = value;
}
}
[Column(Storage = "_Region", DbType = "NVarChar(15)")]
public string Region
{
get { return this._Region; }
set
{
if ((this._Region != value))
this._Region = value;
}
}
[Column(Storage = "_PostalCode", DbType ="NVarChar(10)")]
public string PostalCode
{
get { return this._PostalCode; }
set
{
if ((this._PostalCode != value))
this._PostalCode = value;
}
}
[Column(Storage = "_Country", DbType ="NVarChar(15)")]
public string Country
{
get { return this._Country; }
set
{
if ((this._Country != value))
this._Country = value;
}
}
[Column(Storage = "_Phone", DbType ="NVarChar(24)")]
public string Phone
{
get { return this._Phone; }
set
{
if ((this._Phone != value))
this._Phone = value;
}
}
[Column(Storage = "_Fax", DbType ="NVarChar(24)")]
public string Fax
{
get { return this._Fax; }
set
{
if ((this._Fax != value))
this._Fax = value;
}
}
}
OrdersResultSet 类
public partial class OrdersResultSet
{
private System.Nullable<int> _OrderID;
private string _CustomerID;
private System.Nullable<int> _EmployeeID;
private System.Nullable<System.DateTime> _OrderDate;
private System.Nullable<System.DateTime> _RequiredDate;
private System.Nullable<System.DateTime> _ShippedDate;
private System.Nullable<int> _ShipVia;
private System.Nullable<decimal> _Freight;
private string _ShipName;
private string _ShipAddress;
private string _ShipCity;
private string _ShipRegion;
private string _ShipPostalCode;
private string _ShipCountry;
public OrdersResultSet()
{
}
[Column(Storage = "_OrderID", DbType = "Int")]
public System.Nullable<int> OrderID
{
get { return this._OrderID; }
set
{
if ((this._OrderID != value))
this._OrderID = value;
}
}
[Column(Storage = "_CustomerID", DbType ="NChar(5)")]
public string CustomerID
{
get { return this._CustomerID; }
set
{
if ((this._CustomerID != value))
this._CustomerID = value;
}
}
[Column(Storage = "_EmployeeID", DbType ="Int")]
public System.Nullable<int> EmployeeID
{
get { return this._EmployeeID; }
set
{
if ((this._EmployeeID != value))
this._EmployeeID = value;
}
}
[Column(Storage = "_OrderDate", DbType ="DateTime")]
public System.Nullable<System.DateTime> OrderDate
{
get { return this._OrderDate; }
set
{
if ((this._OrderDate != value))
this._OrderDate = value;
}
}
[Column (Storage = "_RequiredDate", DbType ="DateTime")]
public System.Nullable<System.DateTime> RequiredDate
{
get { return this._RequiredDate; }
set
{
if ((this._RequiredDate != value))
this._RequiredDate = value;
}
}
[Column(Storage = "_ShippedDate", DbType ="DateTime")]
public System.Nullable<System.DateTime> ShippedDate
{
get { return this._ShippedDate; }
set
{
if ((this._ShippedDate != value))
this._ShippedDate = value;
}
}
[Column(Storage = "_ShipVia", DbType = "Int")]
public System.Nullable<int> ShipVia
{
get { return this._ShipVia; }
set
{
if ((this._ShipVia != value))
this._ShipVia = value;
}
}
[Column (Storage = "_Freight", DbType ="Money")]
public System.Nullable<decimal> Freight
{
get { return this._Freight; }
set
{
if ((this._Freight != value))
this._Freight = value;
}
}
[Column (Storage = "_ShipName", DbType ="NVarChar(40)")]
public string ShipName
{
get { return this._ShipName; }
set
{
if ((this._ShipName != value))
this._ShipName = value;
}
}
[Column(Storage = "_ShipAddress", DbType ="NVarChar(60)")]
public string ShipAddress
{
get { return this._ShipAddress; }
set
{
if ((this._ShipAddress != value))
this._ShipAddress = value;
}
}
[Column (Storage = "_ShipCity", DbType ="NVarChar(15)")]
public string ShipCity
{
get { return this._ShipCity; }
set
{
if ((this._ShipCity != value))
this._ShipCity = value;
}
}
[Column(Storage = "_ShipRegion", DbType ="NVarChar(15)")]
public string ShipRegion
{
get { return this._ShipRegion; }
set
{
if ((this._ShipRegion != value))
this._ShipRegion = value;
}
}
[Column(Storage = "_ShipPostalCode", DbType ="NVarChar(10)")]
public string ShipPostalCode
{
get { return this._ShipPostalCode; }
set
{
if ((this._ShipPostalCode != value))
this._ShipPostalCode = value;
}
}
[Column(Storage = "_ShipCountry", DbType = "NVarChar(15)")]
public string ShipCountry
{
get { return this._ShipCountry; }
set
{
if ((this._ShipCountry != value))
this._ShipCountry = value;
}
}
}
这时，仅仅要调用就能够了。
IMultipleResults result =db.Get_Customer_And_Orders("SEVES");
//返回 Customer结果集
IEnumerable<CustomerResultSet>customer =
result.GetResult<CustomerResultSet>();
//返回Orders结果集
IEnumerable<OrdersResultSet> orders =
result.GetResult<OrdersResultSet>();
//在这里，我们读取CustomerResultSet中的数据
foreach (CustomerResultSet cust incustomer)
{
Console.WriteLine(cust.CustomerID);
}
语句描写叙述：这个实例使用存储过程返回客户“SEVES”及其全部订单。
LINQ to SQL 将输出參数映射到引用參数 ，而且对于值类型，它将參数声明为能够为null。
以下的演示样例带有单个输入參数（客户 ID）并返回一个输出參数（该客户的总销售额）。
ALTER PROCEDURE [dbo].[CustOrderTotal]
@CustomerID nchar(5),
@TotalSales money OUTPUT
AS
SELECT @TotalSales =SUM(OD.UNITPRICE*(1-OD.DISCOUNT) * OD.QUANTITY)
FROM ORDERS O, "ORDER DETAILS" OD
where O.CUSTOMERID = @CustomerID AND O.ORDERID= OD.ORDERID
把这个存储过程拖到设计器中，图片例如以下：
其生成代码例如以下：
[Function(Name="dbo.CustOrderTotal")]
public int CustOrderTotal (
[Parameter(Name="CustomerID",DbType="NChar(5) ")]string customerID,
[Parameter (Name="TotalSales",DbType="Money")]
ref System.Nullable<decimal> totalSales)
{
IExecuteResult result = this.ExecuteMethodCall(this,
((MethodInfo)(MethodInfo.GetCurrentMethod())),
customerID, totalSales);
totalSales = ((System.Nullable<decimal>)
(result.GetParameterValue(1)));
return ((int) (result.ReturnValue));
}
我们使用以下的语句调用此存储过程：注意：输出參数是按引用传递的，以支持參数为“in/out”的方案。在这样的情况下，參数仅为“out”。
decimal? totalSales = 0;
string customerID = "ALFKI";
db.CustOrderTotal(customerID, reftotalSales);
Console.WriteLine("Total Sales forCustomer ‘{0}‘ = {1:C}",
customerID, totalSales);
语句描写叙述：这个实例使用返回 Out 參数的存储过程。
好了，就讲到这里了，其增删改操作同理。相信大家通过这5个实例理解了存储过程。
用户定义函数
我们能够在LINQ to SQL中使用用户定义函数。仅仅要把用户定义函数拖到O/R设计器中，LINQ to SQL自己主动使用FunctionAttribute属性和ParameterAttribute属性（假设须要）将其函数指定为方法。这时，我们仅仅需简单调用就可以。
在这里注意：使用用户定义函数的时候必须满足下面形式之中的一个，否则会出现InvalidOperationException异常情况。
具有正确映射属性的方法调用的函数。这里使用FunctionAttribute属性和 ParameterAttribute属性。
特定于LINQ to SQL的静态SQL方法。
.NET Framework方法支持的函数。
以下介绍几个样例：
所谓标量函数是指返回在 RETURNS 子句中定义的类型的单个数据值。能够使用全部标量数据类型，包括 bigint 和 sql_variant。不支持 timestamp 数据类型、用户定义数据类型和非标量类型（如 table 或 cursor）。在 BEGIN...END 块中定义的函数主体包括返回该值的 Transact-SQL 语句系列。返回类型能够是除 text、ntext、image 、cursor 和 timestamp 之外的不论什么数据类型。我们在系统自带的 NORTHWND.MDF数据库中，有3个自己定义函数，这里使用 TotalProductUnitPriceByCategory，其代码例如以下：
ALTER FUNCTION[dbo].[TotalProductUnitPriceByCategory]
(@categoryID int)
RETURNS Money
AS
BEGIN
-- Declare the return variable here
DECLARE @ResultVar Money
-- Add the T-SQL statements to compute the return value here
SELECT @ResultVar = (Select SUM(UnitPrice)
from Products
where CategoryID = @categoryID)
-- Return the result of the function
RETURN @ResultVar
END
我们将其拖到设计器中，LINQ to SQL通过使用 FunctionAttribute 属性将类中定义的client方法映射到用户定义的函数。请注意，这种方法体会构造一个捕获方法调用意向的表达式，并将该表达式传递给 DataContext 进行转换和运行。
[Function(Name="dbo.TotalProductUnitPriceByCategory",
IsComposable=true)]
public System.Nullable<decimal>TotalProductUnitPriceByCategory(
[Parameter (DbType="Int")]System.Nullable<int> categoryID)
{
return ((System.Nullable<decimal>)(this.ExecuteMethodCall(this,
((MethodInfo) (MethodInfo.GetCurrentMethod())), categoryID)
.ReturnValue));
}
我们使用时，能够用下面代码来调用：
var q = from c in db.Categories
select new
{
c.CategoryID,
TotalUnitPrice =
db.TotalProductUnitPriceByCategory(c.CategoryID)
};
这时，LINQ to SQL自己主动生成SQL语句例如以下：
SELECT [t0].[CategoryID],CONVERT(Decimal(29,4),
[dbo].[TotalProductUnitPriceByCategory]([t0].[CategoryID]))
AS [TotalUnitPrice] FROM [dbo].[Categories]AS [t0]
这个样例用法同上一个样例原理基本同样了，MinUnitPriceByCategory自己定义函数例如以下：
ALTER FUNCTION[dbo].[MinUnitPriceByCategory]
(@categoryID INT
)
RETURNS Money
AS
BEGIN
-- Declare the return variable here
DECLARE @ResultVar Money
-- Add the T -SQL statements to compute the return value here
SELECT @ResultVar = MIN(p.UnitPrice) FROM Products as p
WHERE p.CategoryID = @categoryID
-- Return the result of the function
RETURN @ResultVar
END
拖到设计器中，生成代码例如以下：
[Function (Name="dbo.MinUnitPriceByCategory",IsComposable=true)]
public System.Nullable<decimal>MinUnitPriceByCategory(
[Parameter(DbType="Int")]System.Nullable<int> categoryID)
{
return ((System.Nullable<decimal>) (this.ExecuteMethodCall(
this, ((MethodInfo) (MethodInfo.GetCurrentMethod())),
categoryID).ReturnValue));
}
这时能够使用了：注意这里在 LINQ to SQL 查询中，对生成的用户定义函数方法 MinUnitPriceByCategory的内联调用。此函数不会马上运行，这是由于查询会延 迟运行。延迟运行的查询中包括的函数直到此查询运行时才会运行。为此查询生成的 SQL 会转换成对数据库中用户定义函数的调用（请參见此查询后面的生成的 SQL语句），当在查询外部调用这个函数时，LINQ to SQL 会用方法调用表达式创建一个简单查询并运行。
var q =
from p in db.Products
where p.UnitPrice ==
db.MinUnitPriceByCategory(p.CategoryID)
select p;
它自己主动生成的SQL语句例如以下：
SELECT [t0]. [ProductID],[t0].[ProductName], [t0].[SupplierID],
[t0]. [CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice],
[t0]. [UnitsInStock],[t0].[UnitsOnOrder],[t0].[ReorderLevel],
[t0]. [Discontinued]FROM [dbo].[Products]AS [t0]
WHERE [t0]. [UnitPrice] =
[dbo].[MinUnitPriceByCategory]([t0].[CategoryID])
表值函数返回单个行集（与存储过程不同，存储过程可返回多个结果形状）。因为表值函数的返回类型为 Table，因此在 SQL 中能够使用表的不论什么地方均能够使用表值函数。此外，您还能够全然像处理表那样来处理表值函数。
以下的 SQL 用户定义函数显式声明其返回一个 TABLE。因此，隐式定义了所返回的行集结构。
ALTER FUNCTION[dbo].[ProductsUnderThisUnitPrice]
(@price Money
)
RETURNS TABLE
AS
RETURN
SELECT *
FROM Products as P
Where p.UnitPrice < @price
拖到设计器中，LINQ to SQL 按例如以下方式映射此函数：
[Function(Name="dbo.ProductsUnderThisUnitPrice",
IsComposable=true)]
publicIQueryable<ProductsUnderThisUnitPriceResult>
ProductsUnderThisUnitPrice([Parameter(DbType="Money")]
System.Nullable<decimal> price)
{
return this.CreateMethodCallQuery
<ProductsUnderThisUnitPriceResult>(this,
((MethodInfo) (MethodInfo.GetCurrentMethod())), price);
}
这时我们小小的改动一下Discontinued属性为可空的bool类型。
private System.Nullable<bool>_Discontinued;
public System.Nullable<bool>Discontinued
{
}
我们能够这样调用使用了：
var q = from p indb.ProductsUnderThisUnitPrice(10.25M)
where ! (p.Discontinued ?? false)
select p;
其生成 SQL语句例如以下：
SELECT [t0].[ProductID],[t0].[ProductName], [t0].[SupplierID],
[t0].[CategoryID], [t0].[QuantityPerUnit],[t0].[UnitPrice],
[t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0].[ReorderLevel],
[t0].[Discontinued]
FROM [dbo].[ProductsUnderThisUnitPrice](@p0) AS [t0]
WHERE NOT ((COALESCE([t0].[Discontinued],@p1)) = 1)
-- @p0: Input Money (Size = 0; Prec = 19;Scale = 4) [10.25]
-- @p1: Input Int (Size = 0; Prec = 0;Scale = 0) [0]
我们利用上面的ProductsUnderThisUnitPrice用户定义函数，在 LINQ to SQL 中， 调用例如以下：
var q =
from c in db.Categories
join p in db.ProductsUnderThisUnitPrice(8.50M) on
c.CategoryID equals p.CategoryID into prods
from p in prods
select new
{
c.CategoryID,
c.CategoryName,
p.ProductName,
p.UnitPrice
};
其生成的 SQL 代码说明对此函数返回的表运行联接。
SELECT [t0].[CategoryID], [t0]. [CategoryName],
[t1].[ProductName], [t1].[UnitPrice]
FROM [dbo].[Categories] AS [t0]
CROSS JOIN [dbo].[ProductsUnderThisUnitPrice](@p0) AS [t1]
WHERE ([t0]. [CategoryID]) =[t1].[CategoryID]
-- @p0: Input Money (Size = 0; Prec = 19;Scale = 4) [8.50]
DataContext
DataContext作为LINQ to SQL框架的主入口点，为我们 提供了一些方法和属性，本文用几个样例说明DataContext几个典型的应用。
CreateDatabase方法用于在server上创建数据库。
DeleteDatabase方法用于删除由DataContext连接字符串标识的数据 库。
数据库的名称有下面方法来定义：
假设数据库在连接字符串中标识，则使用该连接字符串的名称。
假设存在DatabaseAttribute属性 (Attribute)，则将其Name属性(Property)用作数据库的名称。
假设连接字符串中没有数据库标记，而且使用强类型的DataContext，则会检查与 DataContext继承类名称同样的数据库。假设使用弱类型的DataContext，则会引发异常。
假设已通过使用文件名称创建了DataContext，则会创建与该文件名称相相应的数据库。
我们首先用实体类描写叙述关系数据库表和列的结构的属性。再调用DataContext的CreateDatabase方法，LINQ to SQL会用我们的定义的实体类结构来构造一个新的数据库实例。还能够通过使用 .mdf 文件或仅仅使用文件夹名（取决于连接字符串），将 CreateDatabase与SQL Server一起使用。 LINQ to SQL使用连接字符串来定义要创建的数据库和作为数据库创建位置的server。
说了这么多，用一段实例说明一下吧！
首先，我们新建一个NewCreateDB类用于创建一个名为NewCreateDB.mdf的新数据库，该数据库有一个Person表，有三个字段，分别为PersonID、PersonName、Age。
public class NewCreateDB : DataContext
{
public Table<Person> Persons;
public NewCreateDB (string connection)
:
base(connection)
{
}
public NewCreateDB(System.Data.IDbConnection connection)
:
base(connection)
{
}
}
[Table(Name = "Person")]
public partial class Person :INotifyPropertyChanged
{
private int _PersonID;
private string _PersonName;
private System.Nullable<int> _Age;
public Person() { }
[Column(Storage = "_PersonID", DbType = "INT",
IsPrimaryKey = true)]
public int PersonID
{
get { return this._PersonID; }
set
{
if ((this._PersonID != value))
{
this.OnPropertyChanged("PersonID");
this._PersonID = value;
this.OnPropertyChanged ("PersonID");
}
}
}
[Column(Storage = "_PersonName", DbType ="NVarChar(30)")]
public string PersonName
{
get { return this._PersonName; }
set
{
if ((this._PersonName != value))
{
this.OnPropertyChanged ("PersonName");
this._PersonName = value;
this.OnPropertyChanged ("PersonName");
}
}
}
[Column(Storage = "_Age", DbType = "INT")]
public System.Nullable<int> Age
{
get { return this._Age; }
set
{
if ((this._Age != value))
{
this.OnPropertyChanged("Age");
this._Age = value;
this.OnPropertyChanged("Age");
}
}
}
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged (string PropertyName)
{
if ((this.PropertyChanged != null))
{
this.PropertyChanged(this,
new PropertyChangedEventArgs(PropertyName));
}
}
}
接下来的一段代码先创建一个数据库，在调用 CreateDatabase后，新的数据库就会存在而且会接受一般的查询和命令。接着插入一条记录而且查询。最后删除这个数据库。
//1.新建一个暂时 目录来存放新建的数据库
string userTempFolder =Environment.GetEnvironmentVariable
("SystemDrive") +@"YJingLee";
Directory.CreateDirectory (userTempFolder);
//2.新建数据库NewCreateDB
string userMDF = System.IO.Path.Combine(userTempFolder,
@"NewCreateDB.mdf");
string connStr = String.Format (@"DataSource=.SQLEXPRESS;
AttachDbFilename={0};IntegratedSecurity=True;
Connect Timeout=30;User Instance=True;
Integrated Security = SSPI;",userMDF);
NewCreateDB newDB = newNewCreateDB(connStr);
newDB.CreateDatabase();
//3.插入 数据并查询
var newRow = new Person
{
PersonID = 1,
PersonName = "YJingLee",
Age = 22
};
newDB.Persons.InsertOnSubmit(newRow);
newDB.SubmitChanges();
var q = from x in newDB.Persons
select x;
//4.删除数据库
newDB.DeleteDatabase();
//5.删除暂时文件夹
Directory.Delete (userTempFolder);
DatabaseExists方法用于 尝试通过使用DataContext中的连接打开数据库，假设成功返回true。
以下代码说明是否存在Northwind数据库和NewCreateDB数据库。
// 检測Northwind数据库是否存在
if (db.DatabaseExists())
Console.WriteLine("Northwind数据库存在");
else
Console.WriteLine("Northwind数据库不存在");
//检測 NewCreateDB数据库是否存在
string userTempFolder =Environment.GetEnvironmentVariable("Temp");
string userMDF =System.IO.Path.Combine(userTempFolder,
@"NewCreateDB.mdf");
NewCreateDB newDB = newNewCreateDB(userMDF);
if (newDB.DatabaseExists())
Console.WriteLine("NewCreateDB数据库存在");
else
Console.WriteLine("NewCreateDB数据库不存在 ");
SubmitChanges方法计算要插入、更 新或删除的已改动对象的集，并运行对应命令以实现对数据库的更改。
不管对象做了多少项更改，都仅仅是在更改内存中的副本。并未对数据库中的实际数据做不论什么更改。直到对DataContext显式调用SubmitChanges，所做的更改才会传输到server。调用时，DataContext会设法将我们所做的更改转换为等效的SQL 命令。我们也能够使用自己的自己定义逻辑来重写这些操作，但提交顺序是由 DataContext的一项称作“更改处理器”的服务来协调的。事件的顺序例如以下：
当调用SubmitChanges时，LINQ to SQL会检查已知对象的集合以确定新实例是否已附加到它们。假设已附加，这些新实例将加入到被跟踪对象的集合。
全部具有挂起更改的对象将依照它们之间的依赖关系排序成一个对象序列。假设一个对象的更改依赖于其它对象，则这个对象将排在其依赖项之后。
在即将传输不论什么实际更改时，LINQ to SQL会启动一个事务来封装由各条命令组成的系列。
对对象的更改会逐个转换为SQL命令，然后发送到server。
假设数据库检測到不论什么错误，都会造成提交进程停止并引发异常。将回滚对数据库的全部更改，就像未进行过提交一样。DataContext 仍具有全部更改的完整记录。
以下代码说明的是在数据库中查询CustomerID 为ALFKI的顾客，然后改动其公司名称，第一次更新并调用SubmitChanges()方法，第二次更新了数据但并未调用SubmitChanges()方法。
//查询
Customer cust = db.Customers.First(c =>c.CustomerID == "ALFKI");
//更新数据并调用SubmitChanges()方法
cust.CompanyName = "YJingLee‘sBlog";
db.SubmitChanges();
//更新数据没有调用SubmitChanges()方法
cust.CompanyName ="http://lyj.cnblogs.com";
使用动态查询，这个样例用CreateQuery()方法创建一个 IQueryable<T>类型表达式输出查询的语句。这里给个样例说明一下。有关动态查询详细内容，下一篇介绍。
var c1 =Expression.Parameter(typeof(Customer), "c");
PropertyInfo City =typeof(Customer).GetProperty ("City");
var pred =Expression.Lambda<Func<Customer, bool>>(
Expression.Equal(
Expression.Property(c1, City),
Expression.Constant("Seattle")
), c1
);
IQueryable custs = db.Customers;
Expression expr =Expression.Call(typeof(Queryable), "Where",
new Type[] { custs.ElementType }, custs.Expression, pred);
IQueryable<Customer> q =db.Customers.AsQueryable().
Provider.CreateQuery<Customer>(expr);
Log属性用于将SQL查询或命令打印到TextReader。此方法对了解 LINQto SQL 功能和调试特定的问题可能非常实用。
以下的演示样例使用Log属性在 SQL代码运行前在控制台窗体中显示此代码。我们能够将此属性与查询、插入、更新和删除命令一起使用。
//关闭日志功能
//db.Log = null;
//使用日志功能：日志输出到控制台窗体
db.Log = Console.Out;
var q = from c in db.Customers
where c.City == "London"
select c;
//日志输出到 文件
StreamWriter sw = newStreamWriter(Server.MapPath ("log.txt"), true);
db.Log = sw;
var q = from c in db.Customers
where c.City == "London"
select c;
sw.Close();
动态查询
有这样一个场景：应用程序可能会提供一个用户界面，用户能够使用该用户界面指定一个或多个谓词来筛选数据。这样的情况在编译时不知道查询的细节，动态查询将十分实用。
在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查询。
以下样例说明怎样使用表达式树根据 IQueryable 数据源构造一个动态查询，查询出每一个顾客的ContactName，并用GetCommand方法获取其生成SQL语句。
//根据IQueryable数据 源构造一个查询
IQueryable<Customer> custs =db.Customers;
//组建一个表达式树来创建一个參数
ParameterExpression param =
Expression.Parameter(typeof (Customer), "c");
//组建表达式树:c.ContactName
Expression selector =Expression.Property(param,
typeof (Customer).GetProperty("ContactName"));
Expression pred =Expression.Lambda(selector, param);
//组建表达式树:Select(c=>c.ContactName)
Expression expr = Expression.Call(typeof(Queryable), "Select",
new Type[] { typeof (Customer), typeof(string) },
Expression.Constant(custs), pred);
//使用表达式树来生成动态查询
IQueryable<string> query =db.Customers.AsQueryable()
.Provider.CreateQuery<string>(expr);
//使用GetCommand方法 获取SQL语句
System.Data.Common.DbCommand cmd =db.GetCommand (query);
Console.WriteLine(cmd.CommandText);
生成的 SQL语句为：
SELECT [t0].[ContactName] FROM [dbo]. [Customers]AS [t0]
以下一个样例是“搭建”Where使用方法来动态查询城市在伦敦的顾客。
IQueryable<Customer> custs =db.Customers;
// 创建一个參数c
ParameterExpression param =
Expression.Parameter(typeof(Customer), "c");
//c.City=="London"
Expression left = Expression.Property(param,
typeof(Customer).GetProperty ("City"));
Expression right = Expression.Constant("London");
Expression filter = Expression.Equal(left,right);
Expression pred = Expression.Lambda(filter,param);
//Where(c=>c.City=="London")
Expression expr = Expression.Call(typeof(Queryable),"Where",
new Type[] { typeof(Customer) },
Expression.Constant(custs), pred);
//生成动态查询
IQueryable<Customer> query =db.Customers.AsQueryable()
.Provider.CreateQuery<Customer>(expr);
生成的SQL 语句为：
SELECT [t0].[CustomerID],[t0].[CompanyName], [t0].[ContactName],
[t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region],
[t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax]
FROM [dbo].[Customers] AS [t0] WHERE [t0].[City] = @p0
-- @p0: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
3.OrderBy本例既实现排序功能又实现了过滤功能。
IQueryable<Customer> custs =db.Customers;
//创建一个 參数c
ParameterExpression param =
Expression.Parameter (typeof(Customer), "c");
//c.City=="London"
Expression left = Expression.Property(param,
typeof(Customer).GetProperty ("City"));
Expression right = Expression.Constant("London");
Expression filter = Expression.Equal(left,right);
Expression pred = Expression.Lambda(filter,param);
//Where(c=>c.City=="London")
MethodCallExpression whereCallExpression =Expression.Call(
typeof(Queryable), "Where",
new Type[] { typeof(Customer) },
Expression.Constant(custs), pred);
//OrderBy(ContactName => ContactName)
MethodCallExpression orderByCallExpression= Expression.Call(
typeof(Queryable), "OrderBy",
new Type[] { typeof(Customer), typeof(string) },
whereCallExpression,
Expression.Lambda(Expression.Property
(param, "ContactName"), param));
//生成动态查询
IQueryable<Customer> query =db.Customers.AsQueryable()
.Provider.CreateQuery<Customer> (orderByCallExpression);
以下一张截图显示了怎么动态生成动态查询的过程
生成的SQL语句为：
SELECT [t0].[CustomerID],[t0].[CompanyName], [t0].[ContactName],
[t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region],
[t0].[PostalCode], [t0].[Country], [t0].[Phone],[t0].[Fax]
FROM [dbo].[Customers] AS [t0] WHERE[t0].[City] = @p0
ORDER BY [t0].[ContactName]
-- @p0: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
4.Union
以下的样例使用表达式树动态查询顾客和雇员同在的城市。
//e.City
IQueryable<Customer> custs = db.Customers;
ParameterExpression param1 =
Expression.Parameter(typeof(Customer),"e");
Expression left1 =Expression.Property(param1,
typeof (Customer).GetProperty("City"));
Expression pred1 = Expression.Lambda(left1,param1);
//c.City
IQueryable<Employee> employees =db.Employees;
ParameterExpression param2 =
Expression.Parameter(typeof (Employee),"c");
Expression left2 =Expression.Property(param2,
typeof(Employee).GetProperty ("City"));
Expression pred2 = Expression.Lambda(left2,param2);
//Select(e=>e.City)
Expression expr1 =Expression.Call(typeof(Queryable), "Select",
new Type[] { typeof(Customer), typeof(string) },
Expression.Constant(custs), pred1);
//Select(c=>c.City)
Expression expr2 =Expression.Call(typeof(Queryable), "Select",
new Type[] { typeof(Employee), typeof (string) },
Expression.Constant(employees), pred2);
//生 成动态查询
IQueryable<string> q1 =db.Customers.AsQueryable()
.Provider.CreateQuery<string>(expr1);
IQueryable<string> q2 =db.Employees.AsQueryable()
.Provider.CreateQuery<string>(expr2);
//并集
var q3 = q1.Union(q2);
生成的SQL语句为：
SELECT [t2].[City]
FROM (
SELECT [t0].[City] FROM [dbo]. [Customers] AS [t0]
UNION
SELECT [t1].[City] FROM [dbo].[Employees] AS [t1]
) AS [t2]
视图
我们使用视图和使用数据表类似，仅仅需将视图从“server资源管理器/数据库资源管理器”拖动到O/R 设计器上，自己主动能够创建基于这些视图的实体类。我们能够同操作数据表一样来操作视图了。这里注意：O/R 设计器是一个简单的对象关系映射器，由于它仅支持 1:1 映射关系。换句话说，实体类与数据库表或视图之间仅仅能具有 1:1 映射关系。不支持复杂映射（比如，将一个实体类映射到多个表）。可是，能够将一个实体类映射到一个联接多个相关表的视图。 以下使用NORTHWND数据库中自带的Invoices、QuarterlyOrders 两个视图为例，写出两个范例。
查询：匿名类型形式
我们使用以下代码来查询出ShipCity 在London的发票。
var q =
from i in db.Invoices
where i.ShipCity == "London"
select new
{
i.OrderID,
i.ProductName,
i.Quantity,
i.CustomerName
};
这里，生成的SQL语句同使用数据表类似：
SELECT [t0].[OrderID], [t0].[ProductName],[t0]. [Quantity],
[t0].[CustomerName] FROM [dbo].[Invoices]AS [t0]
WHERE [t0].[ShipCity] = @p0
-- @p0: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
查询：标识映射形式
下例查询出每季的订单。
var q =
from qo in db.Quarterly_Orders
select qo;
生成SQL语句为：
SELECT [t0].[CustomerID],[t0].[CompanyName], [t0]. [City],
[t0].[Country] FROM [dbo].[QuarterlyOrders] AS [t0]
继承支持
LINQ to SQL 支持单表映射，其整个继承层次结构存储在单个数据库表中。该表包括整个层次结构的全部可能数据列的平展联合。（联合是将两个表组合成一个表的结果，组合后的表包括任一原始表中存在的行。）每行中不适用于该行所表示的实例类型的列为 null。
单表映射策略是最简单的继承表示形式，为很多不同类别的查询提供了良好的性能特征，假设我们要在 LINQ to SQL 中实现这样的映射，必须在继承层次结构的根类中指定属性 (Attribute) 和属性 (Attribute) 的属性 (Property)。我们还能够使用O/R设计器来映射继承层次结构，它自己主动生成了代码。
以下为了演示以下的几个样例，我们在O/R设计器内设计例如以下图所看到的的类及其继承关系。
我们学习的时候还是看看其生成的代码吧！
详细设置映射继承层次结构有例如以下几步：
根类加入TableAttribute属性。
为层次结构中的每一个类加入InheritanceMappingAttribute属性，相同是加入到根类中。每一个InheritanceMappingAttribute属性，定义一个Code属性和一个Type属性。Code 属性的值显示在数据库表的IsDiscriminator列中，用来指示该行数据所属的类或子类。Type属性值指定键值所表示的类或子类。
仅在当中一个 InheritanceMappingAttribute属性上，加入一个IsDefault属性用来在数据库表 中的鉴别器值在继承映射中不与不论什么Code值匹配时指定回退映射。
为 ColumnAttribute属性加入一个IsDiscriminator属性来表示这是保存Code值的列。
以下是这张图生成的代码的框架（因为生成的代码太多，我删除了非常多“枝叶”，只保留了基本的框架用于指出事实上质的东西）：
[Table(Name = "dbo.Contacts")]
[InheritanceMapping(Code ="Unknown", Type = typeof (Contact),
IsDefault = true)]
[InheritanceMapping(Code ="Employee", Type = typeof (EmployeeContact))]
[InheritanceMapping(Code ="Supplier", Type = typeof(SupplierContact))]
[InheritanceMapping(Code ="Customer", Type = typeof (CustomerContact))]
[InheritanceMapping(Code ="Shipper", Type = typeof(ShipperContact))]
public partial class Contact :
INotifyPropertyChanging,INotifyPropertyChanged
{
[Column(Storage = "_ContactID",IsPrimaryKey = true,
IsDbGenerated = true)]
public int ContactID{ }
[Column(Storage = "_ContactType",IsDiscriminator = true)]
public string ContactType{ }
}
public abstract partial class FullContact :Contact{ }
public partial class EmployeeContact :FullContact{ }
public partial class SupplierContact :FullContact{ }
public partial class CustomerContact :FullContact{ }
public partial class ShipperContact :Contact{ }
日常我们常常写的形式，对单表查询。
var cons = from c in db.Contacts
select c;
foreach (var con in cons) {
Console.WriteLine("Company name: {0}", con.CompanyName);
Console.WriteLine("Phone: {0}", con.Phone);
Console.WriteLine("This is a {0}", con.GetType());
}
这里我只让其返回想客的联系方式。
var cons = from c indb.Contacts.OfType<CustomerContact>()
select c;
初步学习，我们还是看看生成的SQL语句，这样easy理解。在 SQL语句中查询了ContactType为Customer的联系方式。
SELECT [t0].[ContactType],[t0].[ContactName], [t0].[ContactTitle],
[t0].[Address],[t0].[City], [t0].[Region],[t0].[PostalCode],
[t0].[Country],[t0].[Fax],[t0].[ContactID], [t0].[CompanyName],
[t0].[Phone] FROM [dbo].[Contacts] AS [t0]
WHERE ([t0]. [ContactType] = @p0) AND([t0].[ContactType] IS NOT NULL)
-- @p0: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Customer]
这个样例查找一下发货人的联系方式。
var cons = from c in db.Contacts
where c is ShipperContact
select c;
生成的SQL语句例如以下：查询了ContactType为Shipper的联系方式。大致一看好像非常上面的一样，事实上这里查询出来的列多了非常多。实际上是Contacts表的所有字段。
SELECT [t0].[ContactType],[t0].[ContactID], [t0]. [CompanyName],
[t0].[Phone],[t0].[HomePage], [t0].[ContactName],
[t0].[ContactTitle], [t0].[Address], [t0].[City],
[t0].[Region], [t0].[PostalCode],[t0].[Country],
[t0].[Fax],[t0].[PhotoPath], [t0].[Photo],[t0].[Extension]
FROM [dbo].[Contacts] AS [t0] WHERE([t0].[ContactType] = @p0)
AND ([t0].[ContactType] IS NOT NULL)
-- @p0: Input NVarChar (Size = 7; Prec = 0;Scale = 0) [Shipper]
这个样例就通吃了，所有查找了一番。
var cons = from c in db.Contacts
select c as FullContact;
生成 SQL语句例如以下：查询整个Contacts表。
SELECT [t0]. [ContactType],[t0].[HomePage], [t0].[ContactName],
[t0]. [ContactTitle],[t0].[Address],[t0].[City],
[t0].[Region], [t0]. [PostalCode],[t0].[Country],
[t0].[Fax], [t0].[ContactID],[t0].[CompanyName],
[t0].[Phone],[t0].[PhotoPath],[t0].[Photo], [t0].[Extension]
FROM [dbo].[Contacts] AS [t0]
使用Case形式查找出在伦敦的顾客的联系方式。
var cons = from c in db.Contacts
where c.ContactType == "Customer" &&
((CustomerContact)c).City == "London"
select c;
生成SQL语句例如以下，自己能够看懂了。
SELECT [t0].[ContactType],[t0].[ContactID], [t0]. [CompanyName],
[t0].[Phone], [t0].[HomePage],[t0].[ContactName],
[t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region],
[t0].[PostalCode], [t0].[Country],[t0].[Fax], [t0].[PhotoPath],
[t0].[Photo], [t0].[Extension]FROM [dbo].[Contacts] AS [t0]
WHERE ([t0].[ContactType] = @p0) AND ([t0].[City] = @p1)
-- @p0: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Customer]
-- @p1: Input NVarChar (Size = 6; Prec = 0;Scale = 0) [London]
当插入一条记录时，使用默认的映射关系了，可是在查询时，使用继承的关系了。详细看看生成的SQL 语句就直截了当了。
//插入一条数据默认使用正常的映射关系
Contact contact = new Contact()
{
ContactType = null,
CompanyName = "Unknown Company",
Phone = "333-444-5555"
};
db.Contacts.InsertOnSubmit(contact);
db.SubmitChanges();
//查询一条数据默认使用继承映射关系
var con =
(from c in db.Contacts
where c.CompanyName == "Unknown Company" &&
c.Phone == "333-444-5555"
select c).First();
生成SQL语句例如以下：
INSERT INTO [dbo].[Contacts]([ContactType], [CompanyName],
[Phone]) VALUES (@p0, @p1, @p2)
SELECT TOP (1) [t0].[ContactType], [t0].[ContactID],
[t0]. [CompanyName],[t0].[Phone],[t0].[HomePage],
[t0].[ContactName], [t0].[ContactTitle],[t0].[Address],
[t0].[City],[t0].[Region],[t0].[PostalCode], [t0].[Country],
[t0].[Fax], [t0].[PhotoPath], [t0].[Photo],[t0].[Extension]
FROM [dbo].[Contacts] AS [t0]
WHERE ([t0].[CompanyName] = @p0) AND([t0].[Phone] = @p1)
-- @p0: Input NVarChar (Size = 15; Prec =0; Scale = 0)
[Unknown Company]
-- @p1: Input NVarChar (Size = 12; Prec =0; Scale = 0)
[333-444-5555]
这个样例说明怎样插入发货人的联系方式的一条记录。
//
var ShipperContacts =
from sc in db.Contacts.OfType<ShipperContact>()
where sc.CompanyName == "Northwind Shipper"
select sc;
//
ShipperContact nsc = new ShipperContact()
{
CompanyName = "Northwind Shipper",
Phone = "(123)-456-7890"
};
db.Contacts.InsertOnSubmit(nsc);
db.SubmitChanges();
//
ShipperContacts =
from sc in db.Contacts.OfType<ShipperContact>()
where sc.CompanyName == "Northwind Shipper"
select sc;
//
db.Contacts.DeleteOnSubmit (nsc);
db.SubmitChanges();
生成SQL语句例如以下：
SELECT COUNT(*) AS [value] FROM[dbo].[Contacts] AS [t0]
WHERE ([t0].[CompanyName] = @p0) AND([t0].[ContactType] = @p1)
AND ([t0].[ContactType] IS NOT NULL)
-- @p0: Input NVarChar [Northwind Shipper]
-- @p1: Input NVarChar [Shipper]
INSERT INTO [dbo].[Contacts]([ContactType],[CompanyName], [Phone])
VALUES (@p0, @p1, @p2)
-- @p0: Input NVarChar [Shipper]
-- @p1: Input NVarChar [NorthwindShipper]
-- @p2: Input NVarChar [(123)-456-7890]
SELECT COUNT(*) AS [value] FROM[dbo].[Contacts] AS [t0]
WHERE ([t0].[CompanyName] = @p0) AND([t0].[ContactType] = @p1)
AND ([t0].[ContactType] IS NOT NULL)
-- @p0: Input NVarChar [Northwind Shipper]
-- @p1: Input NVarChar [Shipper]
DELETE FROM [dbo].[Contacts] WHERE ([ContactID]= @p0) AND
([ContactType] = @p1) AND ([CompanyName] =@p2) AND ([Phone] = @p3)
-- @p0: Input Int [159]
-- @p1: Input NVarChar [Shipper]
-- @p2: Input NVarChar [NorthwindShipper]
-- @p3: Input NVarChar [(123)-456-7890]
-- @p4: Input NVarChar [Unknown]
-- @p5: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Supplier]
-- @p6: Input NVarChar (Size = 7; Prec = 0;Scale = 0) [Shipper]
-- @p7: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Employee]
-- @p8: Input NVarChar (Size = 8; Prec = 0;Scale = 0) [Customer]
LINQ To SQL 语法及实例大全,布布扣,bubuko.com
标签：des blog http 使用 os io strong 文件
原文地址：http://www.cnblogs.com/zfyouxi/p/3912375.html
