标签：
适用场景：实现过滤，查询等功能。
说明：与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);
适用场景：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的名字。例如string c = "d";var d = new { c}; 则是可以通过编译的。编译器会创建一个叫做匿名类带有叫c的property。
例如下例：new{c,ContactName,c.Phone};ContactName和Phone都是在映射文件中定义与表中字段相对应的property。编译器读取数据并创建对象时，会创建一个匿名类，这个类有两个属性，为ContactName和Phone，然后根据数据初始化对象。另外编译器还可以重命名property的名字。
var q =
from c in db.Customers
select new {c.ContactName, c.Phone};
上面语句描述：使用 SELECT 和匿名类型返回仅含客户联系人姓名和电话号码的序列
var q =
from e in db.Employees
select new
{
Name = e.FirstName + " " + e.LastName,
Phone = e.HomePhone
};
上面语句描述：使用SELECT和匿名类型返回仅含雇员姓名和电话号码的序列，并将FirstName和LastName字段合并为一个字段“Name”，此外在所得的序列中将HomePhone字段重命名为Phone。
var q =
from p in db.Products
select new
{
p.ProductID,
HalfPrice = p.UnitPrice / 2
};
上面语句描述：使用SELECT和匿名类型返回所有产品的ID以及HalfPrice(设置为产品单价除以2所得的值)的序列。
适用场景：统计数据吧，比如统计一些数据的个数，求和，最小值，最大值，平均数。
说明：返回集合中的元素个数，返回INT类型；不延迟。生成SQL语句为：SELECT COUNT(*) FROM
得到数据库中客户的数量：
var q = db.Customers.Count();
得到数据库中未断货产品的数量：
var q = db.Products.Count(p => !p.Discontinued);
说明：返回集合中的元素个数，返回LONG类型；不延迟。对于元素个数较多的集合可视情况可以选用LongCount来统计元素个数，它返回long类型，比较精确。生成SQL语句为：SELECT COUNT_BIG(*) FROM
var q = db.Customers.LongCount();
说明：返回集合中数值类型元素之和，集合应为INT类型集合；不延迟。生成SQL语句为：SELECT SUM(…) FROM
得到所有订单的总运费：
var q = db.Orders.Select(o => o.Freight).Sum();
得到所有产品的订货总数：
var q = db.Products.Sum(p => p.UnitsOnOrder);
适用场景：在我们表关系中有一对一关系，一对多关系，多对多关系等。对各个表之间的关系，就用这些实现对多个表的操作。
说明：在Join操作中，分别为Join(Join查询), SelectMany(Select一对多选择)和GroupJoin(分组Join查询)。
该扩展方法对两个序列中键匹配的元素进行inner join操作
说明：我们在写查询语句时，如果被翻译成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])
适用场景：对查询出的语句进行排序，比如按时间排序等等。
说明：按指定表达式对集合排序；延迟，：按指定表达式对集合排序；延迟，默认是升序，加上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();
适用场景：分组数据，为我们查找数据缩小范围。
说明：分配并返回对传入参数进行分组操作后的可枚举对象。分组；延迟
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
}
}
}
适用场景：用于判断集合中元素，进一步缩小范围。
说明：用于判断集合中是否有元素满足某一条件；不延迟。（若条件为空，则集合只要不为空就返回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])
)
适用场景：对两个集合的处理，例如追加、合并、取相同项、相交项等等。
说明：连接不同的集合，不会自动过滤相同项；延迟。
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页的数据。请注意，此方法仅适用于按唯一键排序的情况。
说明：new一个对象，使用InsertOnSubmit方法将其加入到对应的集合中，使用SubmitChanges()提交到数据库。
NorthwindDataContext db = new NorthwindDataContext();
var newCustomer = new Customer
{
CustomerID = "MCSFT",
CompanyName = "Microsoft",
ContactName = "John Doe",
ContactTitle = "Sales Manager",
Address = "1 Microsoft Way",
City = "Redmond",
Region = "WA",
PostalCode = "98052",
Country = "USA",
Phone = "(425) 555-1234",
Fax = null
};
db.Customers.InsertOnSubmit(newCustomer);
db.SubmitChanges();
语句描述：使用InsertOnSubmit方法将新客户添加到Customers 表对象。调用SubmitChanges 将此新Customer保存到数据库。
说明：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 = new EmployeeTerritory
{
Employee = newEmployee,
Territory = newTerritory
};
db.Employees.InsertOnSubmit(newEmployee);
db.Territories.InsertOnSubmit(newTerritory);
db.EmployeeTerritories.InsertOnSubmit(newEmployeeTerritory);
db.SubmitChanges();
语句描述：使用InsertOnSubmit方法将新雇员添加到Employees 表中，将新Territory添加到Territories表中，并将新EmployeeTerritory对象添加到与此新Employee对象和新Territory对象有外键关系的EmployeeTerritories表中。调用SubmitChanges将这些新对象及其关系保持到数据库。
说明：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 = "Vice President";
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 时，才会发生推理删除行为。
下表介绍 LINQ to SQL 文档中涉及开放式并发的术语：
| 术语 | 说明 |
|---|---|
| 并发 | 两个或更多用户同时尝试更新同一数据库行的情形。 |
| 并发冲突 | 两个或更多用户同时尝试向一行的一列或多列提交冲突值的情形。 |
| 并发控制 | 用于解决并发冲突的技术。 |
| 开放式并发控制 | 先调查其他事务是否已更改了行中的值，再允许提交更改的技术。相比之下，保守式并发控制则是通过锁定记录来避免发生并发冲突。之所以称作开放式控制，是因为它将一个事务干扰另一事务视为不太可能发生。 |
| 冲突解决 | 通过重新查询数据库刷新出现冲突的项，然后协调差异的过程。刷新对象时，LINQ to SQL 更改跟踪器会保留以下数据： 最初从数据库获取并用于更新检查的值 通过后续查询获得的新数据库值。 LINQ to SQL 随后会确定相应对象是否发生冲突（即它的一个或多个成员值是否已发生更改）。如果此对象发生冲突，LINQ to SQL 下一步会确定它的哪些成员发生冲突。LINQ to SQL 发现的任何成员冲突都会添加到冲突列表中。 |
在 LINQ to SQL 对象模型中，当以下两个条件都得到满足时，就会发生“开放式并发冲突”：客户端尝试向数据库提交更改；数据库中的一个或多个更新检查值自客户端上次读取它们以来已得到更新。 此冲突的解决过程包括查明对象的哪些成员发生冲突，然后决定您希望如何进行处理。
说明：这个例子中在你读取数据之前，另外一个用户已经修改并提交更新了这个数据，所以不会出现冲突。
//我们打开一个新的连接来模拟另外一个用户
NorthwindDataContext otherUser_db = new NorthwindDataContext();
var otherUser_product =
otherUser_db.Products.First(p => p.ProductID == 1);
otherUser_product.UnitPrice = 999.99M;
otherUser_db.SubmitChanges();
//我们当前连接
var product = db.Products.First(p => p.ProductID == 1);
product.UnitPrice = 777.77M;
try
{
db.SubmitChanges();//当前连接执行成功
}
catch (ChangeConflictException)
{
}
说明：我们读取数据之后，另外一个用户获取并提交更新了这个数据，这时，我们更新这个数据时，引起了一个并发冲突。系统发生回滚，允许你可以从数据库检索新更新的数据，并决定如何继续进行您自己的更新。
//当前用户
var product = db.Products.First(p => p.ProductID == 1);
//我们打开一个新的连接来模拟另外一个用户
NorthwindDataContext otherUser_db = new NorthwindDataContext() ;
var otherUser_product =
otherUser_db.Products.First(p => p.ProductID == 1);
otherUser_product.UnitPrice = 999.99M;
otherUser_db.SubmitChanges();
//当前用户修改
product.UnitPrice = 777.77M;
try
{
db.SubmitChanges();
}
catch (ChangeConflictException)
{
//发生异常！
}
说明：下面第一个例子说明查询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;
返回前者的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方法。但是，SQL Server和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类型相比，前者范围更大、精度更高。因此来自SQL Server的数据用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”的雇员。
实际上，通常我们是将数据从数据库中提取出来放入另一层中，应用程序在该层对数据进行处理。这就是 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 = new NorthwindDataContext();
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 请求相关数据，以便稍后在检索到的各个对象中导航时不需要对数据库进行额外的往返。
使用 AssociateWith 方法指定子查询以限制检索的数据量。
在下面的示例中，AssociateWith 方法将检索的 Orders 限制为当天尚未装运的那些 Orders。如果没有此方法，则会检索所有 Orders，即使只需要一个子集。但是生成SQL语句会发现生成了很多SQL语句。
NorthwindDataContext db2 = new NorthwindDataContext();
DataLoadOptions ds = new DataLoadOptions();
ds.AssociateWith<Customer>(
p => p.Orders.Where(o => o.ShipVia > 1));
db2.LoadOptions = ds;
var custs =
from c in db2.Customers
where c.City == "London"
select c;
foreach (var cust in custs)
{
foreach (var ord in cust.Orders)
{
foreach (var orderDetail in ord.OrderDetails)
{
//可以查询出cust.CustomerID, ord.OrderID, ord.ShipVia,
//orderDetail.ProductID, orderDetail.Product.ProductName
}
}
}
语句描述：原始查询未请求数据，在所检索到各个对象的链接中导航如何以触发对数据库的新查询而告终。此示例还说明在延迟加载关系对象时可以使用 Assoicate With 筛选它们。
使用 AsEnumerable<TSource> 可返回类型化为泛型 IEnumerable 的参数。在此示例中，LINQ to SQL（使用默认泛型 Query）会尝试将查询转换为 SQL 并在服务器上执行。但 where 子句引用用户定义的客户端方法 (isValidProduct)，此方法无法转换为 SQL。
解决方法是指定 where 的客户端泛型 IEnumerable<T> 实现以替换泛型 IQueryable<T>。可通过调用 AsEnumerable<TSource>运算符来执行此操作。
var q =
from p in db.Products.AsEnumerable()
where isValidProduct(p)
select p;
语句描述：这个例子就是使用AsEnumerable以便使用Where的客户端IEnumerable实现，而不是默认的IQueryable将在服务器上转换为SQL并执行的默认Query<T>实现。这很有必要，因为Where子句引用了用户定义的客户端方法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 应用程序混合在一起，将当前 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 = new TransactionScope())
{
db.SubmitChanges();
ts.Complete();
}
注意：不能将此方法用于所有数据库。例如，SqlClient 连接在针对 SQL Server 2000 服务器使用时无法提升系统事务。它采取的方法是，只要它发现有使用事务范围的情况，它就会自动向完整的分布式事务登记。
下面用一个例子说明一下事务的使用方法。在这里，也说明了重用 ADO.NET 命令和 DataContext 之间的同一连接。
var q =
from p in db.Products
where p.ProductID == 3
select p;
//使用LINQ to SQL查询出来
//新建一个标准的ADO.NET连接:
SqlConnection nwindConn = new SqlConnection(connString);
nwindConn.Open();
//利用现有的ADO.NET连接来创建一个DataContext:
Northwind interop_db = new Northwind(nwindConn);
SqlTransaction nwindTxn = nwindConn.BeginTransaction();
try
{
SqlCommand cmd = new SqlCommand("UPDATE Products SET"
+"QuantityPerUnit = ‘single item‘ WHERE ProductID = 3");
cmd.Connection = nwindConn;
cmd.Transaction = nwindTxn;
cmd.ExecuteNonQuery();
interop_db.Transaction = nwindTxn;
Product prod1 = interop_db.Products.First(p => p.ProductID == 4);
Product prod2 = interop_db.Products.First(p => p.ProductID == 5);
prod1.UnitsInStock -= 3;
prod2.UnitsInStock -= 5;//这有一个错误，不能为负数
interop_db.SubmitChanges();
nwindTxn.Commit();
}
catch (Exception e)
{
//如果有一个错误，所有的操作回滚
Console.WriteLine(e.Message);
}
nwindConn.Close();
语句描述：这个例子使用预先存在的 ADO.NET 连接创建 Northwind 对象，然后与此对象共享一个 ADO.NET 事务。此事务既用于通过 ADO.NET 连接执行 SQL 命令，又用于通过 Northwind 对象提交更改。当事务因违反 CHECK 约束而中止时，将回滚所有更改，包括通过 SqlCommand 做出的更改，以及通过Northwind 对象做出的更改。
在我们编写程序中，往往需要一些存储过程，在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 Count By Region]")]
public int Customers_Count_By_Region([Parameter
(DbType = "NVarChar(15)")] string param1)
{
IExecuteResult result = this.ExecuteMethodCall(this,
((MethodInfo)(MethodInfo.GetCurrentMethod())), param1);
return ((int)(result.ReturnValue));
}
我们需要时，直接调用就可以了，例如：
int count = db.CustomersCountByRegion("WA");
Console.WriteLine(count);
语句描述：这个实例使用存储过程返回在“WA”地区的客户数。
从数据库中返回行集合，并包含用于筛选结果的输入参数。 当我们执行返回行集合的存储过程时，会用到结果类，它存储从存储过程中返回的结果。
下面的示例表示一个存储过程，该存储过程返回客户行并使用输入参数来仅返回将“London”列为客户城市的那些行的固定几列。
ALTER PROCEDURE [dbo].[Customers By City]
-- Add the parameters for the stored procedure here
(@param1 NVARCHAR(20))
AS
BEGIN
-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON;
SELECT CustomerID, ContactName, CompanyName, City from
Customers as c where c.City=@param1
END
拖到O/R设计器内，它自动生成了以下代码段：
[Function(Name="dbo.[Customers By City]")]
public ISingleResult<Customers_By_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 in result)
{
Console.WriteLine("CustID={0}; City={1}", cust.CustomerID,
cust.City);
}
语句描述：这个实例使用存储过程返回在伦敦的客户的 CustomerID和City。
我们可以在LINQ to SQL中使用用户定义函数。只要把用户定义函数拖到O/R设计器中，LINQ to SQL自动使用FunctionAttribute属性和ParameterAttribute属性（如果需要）将其函数指定为方法。这时，我们只需简单调用即可。
在这里注意：使用用户定义函数的时候必须满足以下形式之一，否则会出现InvalidOperationException异常情况。
下面介绍几个例子：
所谓标量函数是指返回在 RETURNS 子句中定义的类型的单个数据值。可以使用所有标量数据类型，包括 bigint 和 sql_variant。不支持 timestamp 数据类型、用户定义数据类型和非标量类型（如 table 或 cursor）。在 BEGIN...END 块中定义的函数主体包含返回该值的 Transact-SQL 语句系列。返回类型可以是除 text、ntext、image、cursor 和 timestamp 之外的任何数据类型。 我们在系统自带的NORTHWND.MDF数据库中，有3个自定义函数，这里使用TotalProductUnitPriceByCategory，其代码如下：
ALTER FUNCTION [dbo].[TotalProductUnitPriceByCategory]
(@categoryID int)
RETURNS Money
AS
BEGIN
-- Declare the return variable here
DECLARE @ResultVar Money
-- Add the T-SQL statements to compute the return value here
SELECT @ResultVar = (Select SUM(UnitPrice)
from Products
where CategoryID = @categoryID)
-- Return the result of the function
RETURN @ResultVar
END
我们将其拖到设计器中，LINQ to SQL通过使用 FunctionAttribute 属性将类中定义的客户端方法映射到用户定义的函数。请注意，这个方法体会构造一个捕获方法调用意向的表达式，并将该表达式传递给 DataContext 进行转换和执行。
[Function(Name="dbo.TotalProductUnitPriceByCategory",
IsComposable=true)]
public System.Nullable<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)]
public IQueryable<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 in db.ProductsUnderThisUnitPrice(10.25M)
where !(p.Discontinued ?? false)
select p;
其生成SQL语句如下：
SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID], [t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock], [t0].[UnitsOnOrder], [t0].[ReorderLevel], [t0].[Discontinued] FROM [dbo].[ProductsUnderThisUnitPrice](@p0) AS [t0] WHERE NOT ((COALESCE([t0].[Discontinued],@p1)) = 1) -- @p0: Input Money (Size = 0; Prec = 19; Scale = 4) [10.25] -- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0]
我们利用上面的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作为LINQ to SQL框架的主入口点，为我们提供了一些方法和属性，本文用几个例子说明DataContext几个典型的应用。
CreateDatabase方法用于在服务器上创建数据库。
DeleteDatabase方法用于删除由DataContext连接字符串标识的数据库。
数据库的名称有以下方法来定义：
如果数据库在连接字符串中标识，则使用该连接字符串的名称。
如果存在DatabaseAttribute属性(Attribute)，则将其Name属性(Property)用作数据库的名称。
如果连接字符串中没有数据库标记，并且使用强类型的DataContext，则会检查与DataContext继承类名称相同的数据库。如果使用弱类型的DataContext，则会引发异常。
如果已通过使用文件名创建了DataContext，则会创建与该文件名相对应的数据库。
我们首先用实体类描述关系数据库表和列的结构的属性。再调用DataContext的CreateDatabase方法，LINQ to SQL会用我们的定义的实体类结构来构造一个新的数据库实例。还可以通过使用 .mdf 文件或只使用目录名（取决于连接字符串），将 CreateDatabase与SQL Server一起使用。LINQ to SQL使用连接字符串来定义要创建的数据库和作为数据库创建位置的服务器。
说了这么多，用一段实例说明一下吧！
首先，我们新建一个NewCreateDB类用于创建一个名为NewCreateDB.mdf的新数据库，该数据库有一个Person表，有三个字段，分别为PersonID、PersonName、Age。（点击展开代码）
代码在这里展开接下来的一段代码先创建一个数据库，在调用CreateDatabase后，新的数据库就会存在并且会接受一般的查询和命令。接着插入一条记录并且查询。最后删除这个数据库。
//1.新建一个临时文件夹来存放新建的数据库
string userTempFolder = Environment.GetEnvironmentVariable
("SystemDrive") + @"\YJingLee";
Directory.CreateDirectory(userTempFolder);
//2.新建数据库NewCreateDB
string userMDF = System.IO.Path.Combine(userTempFolder,
@"NewCreateDB.mdf");
string connStr = String.Format(@"Data Source=.\SQLEXPRESS;
AttachDbFilename={0};Integrated Security=True;
Connect Timeout=30;User Instance=True;
Integrated Security = SSPI;", userMDF);
NewCreateDB newDB = new NewCreateDB(connStr);
newDB.CreateDatabase();
//3.插入数据并查询
var newRow = new Person
{
PersonID = 1,
PersonName = "YJingLee",
Age = 22
};
newDB.Persons.InsertOnSubmit(newRow);
newDB.SubmitChanges();
var q = from x in newDB.Persons
select x;
//4.删除数据库
newDB.DeleteDatabase();
//5.删除临时目录
Directory.Delete(userTempFolder);
DatabaseExists方法用于尝试通过使用DataContext中的连接打开数据库，如果成功返回true。
下面代码说明是否存在Northwind数据库和NewCreateDB数据库 。
//检测Northwind数据库是否存在
if (db.DatabaseExists())
Console.WriteLine("Northwind数据库存在");
else
Console.WriteLine("Northwind数据库不存在");
//检测NewCreateDB数据库是否存在
string userTempFolder = Environment.GetEnvironmentVariable("Temp");
string userMDF = System.IO.Path.Combine(userTempFolder,
@"NewCreateDB.mdf");
NewCreateDB newDB = new NewCreateDB(userMDF);
if (newDB.DatabaseExists())
Console.WriteLine("NewCreateDB数据库存在");
else
Console.WriteLine("NewCreateDB数据库不存在");
SubmitChanges方法计算要插入、更新或删除的已修改对象的集，并执行相应命令以实现对数据库的更改。
无论对象做了多少项更改，都只是在更改内存中的副本。并未对数据库中的实际数据做任何更改。直到对DataContext显式调用SubmitChanges，所做的更改才会传输到服务器。调用时，DataContext会设法将我们所做的更改转换为等效的SQL命令。我们也可以使用自己的自定义逻辑来重写这些操作，但提交顺序是由DataContext的一项称作“更改处理器”的服务来协调的。事件的顺序如下：
如果数据库检测到任何错误，都会造成提交进程停止并引发异常。将回滚对数据库的所有更改，就像未进行过提交一样。DataContext 仍具有所有更改的完整记录。
下面代码说明的是在数据库中查询CustomerID为ALFKI的顾客，然后修改其公司名称，第一次更新并调用SubmitChanges()方法，第二次更新了数据但并未调用SubmitChanges()方法。
//查询 Customer cust = db.Customers.First(c => c.CustomerID == "ALFKI"); //更新数据并调用SubmitChanges()方法 cust.CompanyName = "YJingLee‘s Blog"; db.SubmitChanges(); //更新数据没有调用SubmitChanges()方法 cust.CompanyName = "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。此方法对了解 LINQ to SQL 功能和调试特定的问题可能很有用。
下面的示例使用Log属性在SQL代码执行前在控制台窗口中显示此代码。我们可以将此属性与查询、插入、更新和删除命令一起使用。
//关闭日志功能
//db.Log = null;
//使用日志功能：日志输出到控制台窗口
db.Log = Console.Out;
var q = from c in db.Customers
where c.City == "London"
select c;
//日志输出到文件
StreamWriter sw = new StreamWriter(Server.MapPath("log.txt"), true);
db.Log = sw;
var q = from c in db.Customers
where c.City == "London"
select c;
sw.Close();
有这样一个场景：应用程序可能会提供一个用户界面，用户可以使用该用户界面指定一个或多个谓词来筛选数据。这种情况在编译时不知道查询的细节，动态查询将十分有用。
在LINQ中，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]
本例既实现排序功能又实现了过滤功能。
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]
下面的例子使用表达式树动态查询顾客和雇员同在的城市。
//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]
我们使用视图和使用数据表类似，只需将视图从“服务器资源管理器/数据库资源管理器”拖动到O/R 设计器上，自动可以创建基于这些视图的实体类。我们可以同操作数据表一样来操作视图了。这里注意：O/R 设计器是一个简单的对象关系映射器，因为它仅支持 1:1 映射关系。换句话说，实体类与数据库表或视图之间只能具有 1:1 映射关系。不支持复杂映射（例如，将一个实体类映射到多个表）。但是，可以将一个实体类映射到一个联接多个相关表的视图。 下面使用NORTHWND数据库中自带的Invoices、Quarterly Orders两个视图为例，写出两个范例。
我们使用下面代码来查询出ShipCity 在London的发票。
var q =
from i in db.Invoices
where i.ShipCity == "London"
select new
{
i.OrderID,
i.ProductName,
i.Quantity,
i.CustomerName
};
这里，生成的SQL语句同使用数据表类似：
SELECT [t0].[OrderID], [t0].[ProductName], [t0].[Quantity], [t0].[CustomerName] FROM [dbo].[Invoices] AS [t0] WHERE [t0].[ShipCity] = @p0 -- @p0: Input NVarChar (Size = 6; Prec = 0; Scale = 0) [London]
下例查询出每季的订单。
var q =
from qo in db.Quarterly_Orders
select qo;
生成SQL语句为：
SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[City], [t0].[Country] FROM [dbo].[Quarterly Orders] AS [t0]
LINQ to SQL 支持单表映射，其整个继承层次结构存储在单个数据库表中。该表包含整个层次结构的所有可能数据列的平展联合。（联合是将两个表组合成一个表的结果，组合后的表包含任一原始表中存在的行。）每行中不适用于该行所表示的实例类型的列为 null。
单表映射策略是最简单的继承表示形式，为许多不同类别的查询提供了良好的性能特征，如果我们要在 LINQ to SQL 中实现这种映射，必须在继承层次结构的根类中指定属性 (Attribute) 和属性 (Attribute) 的属性 (Property)。我们还可以使用O/R设计器来映射继承层次结构，它自动生成了代码。
下面为了演示下面的几个例子，我们在O/R设计器内设计如下图所示的类及其继承关系。
我们学习的时候还是看看其生成的代码吧！
具体设置映射继承层次结构有如下几步：
下面是这张图生成的代码的框架（由于生成的代码太多，我删除了很多“枝叶”，仅仅保留了主要的框架用于指出其实质的东西）：
[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 in db.Contacts.OfType<CustomerContact>()
select c;
初步学习，我们还是看看生成的SQL语句，这样容易理解。在SQL语句中查询了ContactType为Customer的联系方式。
SELECT [t0].[ContactType], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address],[t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Fax],[t0].[ContactID], [t0].[CompanyName], [t0].[Phone] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[ContactType] = @p0) AND ([t0].[ContactType] IS NOT NULL) -- @p0: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Customer]
这个例子查找一下发货人的联系方式。
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]
这个例子说明如何插入发货人的联系方式的一条记录。
//1.在插入之前查询一下，没有数据
var ShipperContacts =
from sc in db.Contacts.OfType<ShipperContact>()
where sc.CompanyName == "Northwind Shipper"
select sc;
//2.插入数据
ShipperContact nsc = new ShipperContact()
{
CompanyName = "Northwind Shipper",
Phone = "(123)-456-7890"
};
db.Contacts.InsertOnSubmit(nsc);
db.SubmitChanges();
//3.查询数据，有一条记录
ShipperContacts =
from sc in db.Contacts.OfType<ShipperContact>()
where sc.CompanyName == "Northwind Shipper"
select sc;
//4.删除记录
db.Contacts.DeleteOnSubmit(nsc);
db.SubmitChanges();
生成SQL语句如下：
SELECT COUNT(*) AS [value] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[CompanyName] = @p0) AND ([t0].[ContactType] = @p1) AND ([t0].[ContactType] IS NOT NULL) -- @p0: Input NVarChar [Northwind Shipper] -- @p1: Input NVarChar [Shipper] INSERT INTO [dbo].[Contacts]([ContactType], [CompanyName], [Phone]) VALUES (@p0, @p1, @p2) -- @p0: Input NVarChar [Shipper] -- @p1: Input NVarChar [Northwind Shipper] -- @p2: Input NVarChar [(123)-456-7890] SELECT COUNT(*) AS [value] FROM [dbo].[Contacts] AS [t0] WHERE ([t0].[CompanyName] = @p0) AND ([t0].[ContactType] = @p1) AND ([t0].[ContactType] IS NOT NULL) -- @p0: Input NVarChar [Northwind Shipper] -- @p1: Input NVarChar [Shipper] DELETE FROM [dbo].[Contacts] WHERE ([ContactID] = @p0) AND ([ContactType] = @p1) AND ([CompanyName] = @p2) AND ([Phone] = @p3) -- @p0: Input Int [159] -- @p1: Input NVarChar [Shipper] -- @p2: Input NVarChar [Northwind Shipper] -- @p3: Input NVarChar [(123)-456-7890] -- @p4: Input NVarChar [Unknown] -- @p5: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Supplier] -- @p6: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Shipper] -- @p7: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Employee] -- @p8: Input NVarChar (Size = 8; Prec = 0; Scale = 0) [Customer]
标签：
原文地址：http://www.cnblogs.com/ms-wlj/p/4423560.html
