一、引言

LINQ to SQL是.NET Framework 3.5版的组件，该版本提供了用于将关系数据作为对象进行管理的运行时基础结构。

1、Where

适用场景：实现过滤，查询等功能。

说明：与SQL命令中的Where作用相似，都是起到范围限定也就是过滤作用的，而判断条件就是它后面所接的子句。Where操作包括3种形式，分别为简单形式、关系条件形式、First()形式。下面分别用实例举例下：

1.1、简单形式：

例如：使用where筛选在伦敦的客户

var q =
    from c in db.Customers
    where c.City == "London"
    select c;

1.2、关系条件形式：

筛选库存量在订货点水平之下但未断货的产品：

var q =
    from p in db.Products
    where p.UnitsInStock <= p.ReorderLevel && !p.Discontinued
    select p;

1.3、First()形式：

返回集合中的一个元素，其实质就是在SQL语句中加TOP (1)。

简单用法：选择表中的第一个发货方。

Shipper shipper = db.Shippers.First();

元素：选择CustomerID 为“BONAP”的单个客户

Customer cust = db.Customers.First(c => c.CustomerID == "BONAP");

条件：选择运费大于 10.00 的订单：

Order ord = db.Orders.First(o => o.Freight > 10.00M);

2、Select/Distinct

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

说明：和SQL命令中的select作用相似但位置不同，查询表达式中的select及所接子句是放在表达式最后并把子句中的变量也就是结果返回回来；延迟。Select/Distinct操作包括9种形式，分别为简单用法、匿名类型形式、条件形式、指定类型形式、筛选形式、整形类型形式、嵌套类型形式、本地方法调用形式、Distinct形式。

2.1、简单用法：

这个示例返回仅含客户联系人姓名的序列。

var q =
    from c in db.Customers
    select c.ContactName;

注意：这个语句只是一个声明或者一个描述，并没有真正把数据取出来，只有当你需要该数据的时候，它才会执行这个语句，这就是延迟加载(deferred loading)。如果，在声明的时候就返回的结果集是对象的集合。你可以使用ToList() 或ToArray()方法把查询结果先进行保存，然后再对这个集合进行查询。当然延迟加载(deferred loading)可以像拼接SQL语句那样拼接查询语法，再执行它。

2.2、匿名类型形式：

说明：匿名类型是C#3.0中新特性。其实质是编译器根据我们自定义自动产生一个匿名的类来帮助我们实现临时变量的储存。匿名类型还依赖于另外一个特性：支持根据property来创建对象。比如，var d = new { Name = "s" };编译器自动产生一个有property叫做Name的匿名类，然后按这个类型分配内存，并初始化对象。但是var d = new {"s"};是编译不通过的。因为，编译器不知道匿名类中的property的名字。例如string c = "d";var d = new { c}; 则是可以通过编译的。编译器会创建一个叫做匿名类带有叫c的property。 例如下例：new{c,ContactName,c.Phone};ContactName和Phone都是在映射文件中定义与表中字段相对应的property。编译器读取数据并创建对象时，会创建一个匿名类，这个类有两个属性，为ContactName和Phone，然后根据数据初始化对象。另外编译器还可以重命名property的名字。

var q =
    from c in db.Customers
    select new {c.ContactName, c.Phone};

上面语句描述：使用 SELECT 和匿名类型返回仅含客户联系人姓名和电话号码的序列 

2.3、条件形式：

说明：生成SQL语句为：case when condition then else。

var q =
    from p in db.Products
    select new
    {
        p.ProductName,
        Availability =
        p.UnitsInStock - p.UnitsOnOrder < 0 ?
        "Out Of Stock" : "In Stock"
    };

上面语句描述：使用SELECT和条件语句返回产品名称和产品供货状态的序列。

2.4、指定类型形式：

说明：该形式返回你自定义类型的对象集。

var q =
    from e in db.Employees
    select new Name
    {
        FirstName = e.FirstName,
        LastName = e.LastName
    };

上面语句描述：使用SELECT和已知类型返回雇员姓名的序列。

2.5、筛选形式：

说明：结合where使用，起到过滤作用。

var q =
    from c in db.Customers
    where c.City == "London"
    select c.ContactName;

上面语句描述：使用SELECT和WHERE返回仅含伦敦客户联系人姓名的序列。

2.6、shaped形式(整形类型)：

说明：其select操作使用了匿名对象，而这个匿名对象中，其属性也是个匿名对象。

var q =
    from c in db.Customers
    select new {
        c.CustomerID,
        CompanyInfo = new {c.CompanyName, c.City, c.Country},
        ContactInfo = new {c.ContactName, c.ContactTitle}
    };

语句描述：使用SELECT 和匿名类型返回有关客户的数据的整形子集。查询顾客的ID和公司信息（公司名称，城市，国家）以及联系信息（联系人和职位）。  

2.7、嵌套类型形式：

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
    };

说明：返回的对象集中的每个对象DiscountedProducts属性中，又包含一个集合。也就是每个对象也是一个集合类。

语句描述：使用嵌套查询返回所有订单及其OrderID 的序列、打折订单中项目的子序列以及免送货所省下的金额。

2.8、本地方法调用形式(LocalMethodCall)：

这个例子在查询中调用本地方法PhoneNumberConverter将电话号码转换为国际格式。

var q = from c in db.Customers
         where c.Country == "UK" || c.Country == "USA"
         select new
         {
             c.CustomerID,
             c.CompanyName,
             Phone = c.Phone,
             InternationalPhone =
             PhoneNumberConverter(c.Country, c.Phone)
         };

PhoneNumberConverter方法如下：

public string PhoneNumberConverter(string Country, string Phone)
{
    Phone = Phone.Replace(" ", "").Replace(")", ")-");
    switch (Country)
    {
        case "USA":
            return "1-" + Phone;
        case "UK":
            return "44-" + Phone;
        default:
            return Phone;
    }
}

下面也是使用了这个方法将电话号码转换为国际格式并创建XDocument

XDocument doc = new XDocument(
    new XElement("Customers", from c in db.Customers
              where c.Country == "UK" || c.Country == "USA"
              select (new XElement("Customer",
                      new XAttribute("CustomerID", c.CustomerID),
                      new XAttribute("CompanyName", c.CompanyName),
                      new XAttribute("InterationalPhone",
                      PhoneNumberConverter(c.Country, c.Phone))
                     ))));

2.9、Distinct形式：

说明：筛选字段中不相同的值。用于查询不重复的结果集。生成SQL语句为：SELECT DISTINCT [City] FROM [Customers]

var q = (
    from c in db.Customers
    select c.City )
    .Distinct();

语句描述：查询顾客覆盖的国家。

3、Count/Sum/Min/Max/Avg

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

3.1、Count

说明：返回集合中的元素个数，返回INT类型；不延迟。生成SQL语句为：SELECT COUNT(*) FROM

var q = db.Products.Count(p => !p.Discontinued);

3.2、Min

查找每个类别中单价最低的产品：

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
    };

3.3、Max

说明：返回集合中元素的最大值；不延迟。生成SQL语句为：SELECT MAX(…) FROM

查找任意产品的最大库存量：

var q = db.Products.Max(p => p.UnitsInStock);

3.4、Average

说明：返回集合中的数值类型元素的平均值。集合应为数字类型集合，其返回值类型为double；不延迟。生成SQL语句为：SELECT AVG(…) FROM

得到所有订单的平均运费：

var q = db.Orders.Select(o => o.Freight).Average();

3.5、Aggregate

说明：根据输入的表达式获取聚合值；不延迟。即是说：用一个种子值与当前元素通过指定的函数来进行对比来遍历集合中的元素，符合条件的元素保留下来。如果没有指定种子值的话，种子值默认为集合的第一个元素。

4、Join

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

说明：在Join操作中，分别为Join(Join查询), SelectMany(Select一对多选择)和GroupJoin(分组Join查询)。 该扩展方法对两个序列中键匹配的元素进行inner join操作

4.1、SelectMany

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

4.1.1、一对多关系(1 to Many)：

var q =
    from c in db.Customers
    from o in c.Orders
    where c.City == "London"
    select o;

语句描述：Customers与Orders是一对多关系。即Orders在Customers类中以EntitySet形式出现。所以第二个from是从c.Orders而不是db.Orders里进行筛选。这个例子在From子句中使用外键导航选择伦敦客户的所有订单。

4.1.2、多对多关系(Many to Many)：

var q =
    from e in db.Employees
    from et in e.EmployeeTerritories
    where e.City == "Seattle"
    select new
    {
        e.FirstName,
        e.LastName,
        et.Territory.TerritoryDescription
    };

说明：多对多关系一般会涉及三个表(如果有一个表是自关联的，那有可能只有2个表)。这一句语句涉及Employees, EmployeeTerritories, Territories三个表。它们的关系是1：M：1。Employees和Territories没有很明确的关系。

4.1.3、自联接关系：

var q =
    from e1 in db.Employees
    from e2 in e1.Employees
    where e1.City == e2.City
    select new {
        FirstName1 = e1.FirstName, LastName1 = e1.LastName,
        FirstName2 = e2.FirstName, LastName2 = e2.LastName,
        e1.City
    };

语句描述：这个例子在select 子句中使用外键导航筛选成对的雇员，每对中一个雇员隶属于另一个雇员，且两个雇员都来自相同城市。

4.2、双向联接(Two way join)：

此示例显式联接两个表并从这两个表投影出结果：

var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID
    equals o.CustomerID into orders
    select new
    {
        c.ContactName,
        OrderCount = orders.Count()
    };

说明：在一对多关系中，左边是1，它每条记录为c（from c in db.Customers），右边是Many，其每条记录叫做o ( join o in db.Orders )，每对应左边的一个c，就会有一组o，那这一组o，就叫做orders，也就是说，我们把一组o命名为orders，这就是into用途。这也就是为什么在select语句中，orders可以调用聚合函数Count。在T-SQL中，使用其内嵌的T-SQL返回值作为字段值。

4.3、左外部联接(Left Outer Join)：

此示例说明如何通过使用 此示例说明如何通过使用DefaultIfEmpty() 获取左外部联接。在雇员没有订单时，DefaultIfEmpty()方法返回null：

var q =
    from e in db.Employees
    join o in db.Orders on e equals o.Employee into ords
    from o in ords.DefaultIfEmpty()
    select new
    {
        e.FirstName,
        e.LastName,
        Order = o
    };

说明：以Employees左表，Orders右表，Orders 表中为空时，用null值填充。Join的结果重命名ords，使用DefaultIfEmpty()函数对其再次查询。其最后的结果中有个Order，因为from o in ords.DefaultIfEmpty() 是对ords组再一次遍历，所以，最后结果中的Order并不是一个集合。但是，如果没有from o in ords.DefaultIfEmpty() 这句，最后的select语句写成select new { e.FirstName, e.LastName, Order = ords }的话，那么Order就是一个集合。

4.4、投影的Let赋值(Projected let assignment)：

说明：let语句是重命名。let位于第一个from和select语句之间。

这个例子从联接投影出最终“Let”表达式：

var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID
    equals o.CustomerID into ords
    let z = c.City + c.Country
    from o in ords
    select new
    {
        c.ContactName,
        o.OrderID,
        z
    };

4.5、组合键(Composite Key)：

这个例子显示带有组合键的联接：

var q =
    from o in db.Orders
    from p in db.Products
    join d in db.OrderDetails
        on new
        {
            o.OrderID,
            p.ProductID
        } equals
            new
            {
                d.OrderID,
                d.ProductID
            }
	       into details
    from d in details
    select new
    {
        o.OrderID,
        p.ProductID,
        d.UnitPrice
    };

说明：使用三个表，并且用匿名类来说明：使用三个表，并且用匿名类来表示它们之间的关系。它们之间的关系不能用一个键描述清楚，所以用匿名类，来表示组合键。还有一种是两个表之间是用组合键表示关系的，不需要使用匿名类。

4.6、可为null/不可为null的键关系(Nullable/Nonnullable Key Relationship)：

这个实例显示如何构造一侧可为 null 而另一侧不可为 null 的联接：

var q =
    from o in db.Orders
    join e in db.Employees
        on o.EmployeeID equals
        (int?)e.EmployeeID into emps
    from e in emps
    select new
    {
        o.OrderID,
        e.FirstName
    };

5、Order By

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

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

var q =
    from o in db.Orders
    where o.EmployeeID == 1
    orderby o.ShipCountry, o.Freight descending
    select o;

语句描述：使用orderby先按发往国家再按运费从高到低的顺序对 EmployeeID 1 的订单进行排序。

5.1、带GroupBy形式

var q =
    from p in db.Products
    group p by p.CategoryID into g
    orderby g.Key
    select new {
        g.Key,
        MostExpensiveProducts =
            from p2 in g
            where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
            select p2
    };

语句描述：使用orderby、Max 和 Group By 得出每种类别中单价最高的产品，并按 CategoryID 对这组产品进行排序。

6、Group By/Having

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

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

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的值。

6.1、表达式(Expression)

var categories =
    from p in db.Products
    group p by new { Criterion = p.UnitPrice > 10 } into g
    select g;

语句描述：使用Group By返回两个产品序列。第一个序列包含单价大于10的产品。第二个序列包含单价小于或等于10的产品。

说明：按产品单价是否大于10分类。其结果分为两类，大于的是一类，小于及等于为另一类。

7、Exists/In/Any/All/Contains

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

7.1、Any

说明：用于判断集合中是否有元素满足某一条件；不延迟。（若条件为空，则集合只要不为空就返回True，否则为False）。有2种形式，分别为简单形式和带条件形式。

仅返回至少有一种产品断货的类别：

var q =

    from c in db.Categories

    where c.Products.Any(p => p.Discontinued)

    select c;

7.2、All

说明：用于判断集合中所有元素是否都满足某一条件；不延迟

var q =
    from c in db.Customers
    where c.Orders.All(o => o.ShipCity == c.City)
    select c;

语句描述：这个例子返回所有订单都运往其所在城市的客户或未下订单的客户。

7.3、Contains

说明：用于判断集合中是否包含有某一元素；不延迟。它是对两个序列进行连接操作的。

string[] customerID_Set =
    new string[] { "AROUT", "BOLID", "FISSA" };var q = (
    from o in db.Orders
    where customerID_Set.Contains(o.CustomerID)
    select o).ToList();

语句描述：查找"AROUT", "BOLID" 和 "FISSA" 这三个客户的订单。先定义了一个数组，在LINQ to SQL中使用Contains，数组中包含了所有的CustomerID，即返回结果中，所有的CustomerID都在这个集合内。也就是in。

8、Concat/Union/Intersect/Except

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

8.1、Concat（连接）

说明：连接不同的集合，不会自动过滤相同项；延迟。

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
         }
        );

语句描述：返回所有消费者和雇员的姓名和电话。

8.2、Union（合并）

说明：连接不同的集合，自动过滤相同项；延迟。即是将两个集合进行合并操作，过滤相同的项。

var q = (
         from c in db.Customers
         select c.Country
        ).Union(
         from e in db.Employees
         select e.Country
        );

语句描述：查询顾客和职员所在的国家。

8.3、Intersect（相交）

说明：取相交项；延迟。即是获取不同集合的相同项（交集）。即先遍历第一个集合，找出所有唯一的元素，然后遍历第二个集合，并将每个元素与前面找出的元素作对比，返回所有在两个集合内都出现的元素。

var q = (
         from c in db.Customers
         select c.Country
        ).Intersect(
         from e in db.Employees
         select e.Country
        );

语句描述：查询顾客和职员同在的国家。

8.4、Except（与非）

说明：排除相交项；延迟。即是从某集合中删除与另一个集合中相同的项。先遍历第一个集合，找出所有唯一的元素，然后再遍历第二个集合，返回第二个集合中所有未出现在前面所得元素集合中的元素。

var q = (
         from c in db.Customers
         select c.Country
        ).Except(
         from e in db.Employees
         select e.Country
        );

语句描述：查询顾客和职员不同的国家。

9、Top/Bottom和Paging和SqlMethods

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

9.1、Take

说明：获取集合的前n个元素；延迟。即只返回限定数量的结果集。

var q = (
    from e in db.Employees
    orderby e.HireDate
    select e)
    .Take(5);

语句描述：选择所雇用的前5个雇员。

9.2、Skip

说明：跳过集合的前n个元素；延迟。即我们跳过给定的数目返回后面的结果集。

var q = (
    from p in db.Products
    orderby p.UnitPrice descending
    select p)
    .Skip(10);

语句描述：选择10种最贵产品之外的所有产品。

9.3、TakeWhile

说明：直到某一条件成立就停止获取；延迟。即用其条件去依次判断源序列中的元素，返回符合判断条件的元素，该判断操作将在返回false或源序列的末尾结束 。

9.4、Paging（分页）操作

适用场景：结合Skip和Take就可实现对数据分页操作。

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页的数据。请注意，此方法仅适用于按唯一键排序的情况。  

9.5、SqlMethods操作

在LINQ to SQL语句中，为我们提供了SqlMethods操作，进一步为我们提供了方便，例如Like方法用于自定义通配表达式，Equals用于相比较是否相等。

9.5.1、Like

自定义的通配表达式。%表示零长度或任意长度的字符串；_表示一个字符；[]表示在某范围区间的一个字符；[^]表示不在某范围区间的一个字符。比如查询消费者ID以“C”开头的消费者。 

var q = from c in db.Customers
        where SqlMethods.Like(c.CustomerID, "C%")
        select c;

9.5.2、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 天内已发货的所有订单。

9.6、已编译查询操作(Compiled Query)

说明：在之前我们没有好的方法对写出的SQL语句进行编辑重新查询，现在我们可以这样做，看下面一个例子：

//1.创建compiled query
NorthwindDataContext db = new NorthwindDataContext();var fn = CompiledQuery.Compile(
    (NorthwindDataContext db2, string city) =>
    from c in db2.Customers
    where c.City == city
    select c);
//2.查询城市为London的消费者,用LonCusts集合表示，这时可以用数据控件绑定        
var LonCusts = fn(db, "London");
//3.查询城市为Seattle的消费者
var SeaCusts = fn(db, "Seattle");

语句描述：这个例子创建一个已编译查询，然后使用它检索输入城市的客户。

10、Insert

说明：new一个对象，使用InsertOnSubmit方法将其加入到对应的集合中，使用SubmitChanges()提交到数据库。

10.1、一对多关系

说明：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将这些新对象及其关系保存到数据库。

10.2、多对多关系

说明：在多对多关系中，我们需要依次提交。

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将这些新对象及其关系保持到数据库。

10.3、使用动态CUD重写(Override using Dynamic CUD)

说明：CUD就是Create、Update、Delete的缩写。下面的例子就是新建一个ID(主键)为32的Region，不考虑数据库中有没有ID为32的数据，如果有则替换原来的数据，没有则插入。

Region nwRegion = new Region()
{
    RegionID = 32,
    RegionDescription = "Rainy"
};
db.Regions.InsertOnSubmit(nwRegion);
db.SubmitChanges();

语句描述：使用DataContext提供的分部方法InsertRegion插入一个区域。对SubmitChanges 的调用调用InsertRegion 重写，后者使用动态CUD运行Linq To SQL生成的默认SQL查询。

11、Update

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

11.1、多项更改

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将对检索到的进行的更新保持回数据库。

12、Delete和使用Attach

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将此删除保持到数据库。

12.1、推理删除(Inferred Delete)

说明：Order与OrderDetail是一对多关系，在上面的例子，我们全部删除CustomerID为WARTH和EmployeeID为3 的数据，那么我们不须全部删除呢？例如Order的OrderID为10248的OrderDetail有很多，但是我们只要删除ProductID为11的OrderDetail。这时就用Remove方法。

Order order = db.Orders.First(x => x.OrderID == 10248);
OrderDetail od = order.OrderDetails.First(d => d.ProductID == 11);
order.OrderDetails.Remove(od);
db.SubmitChanges();

语句描述语句描述：这个例子说明在实体对象的引用实体将该对象从其EntitySet 中移除时，推理删除如何导致在该对象上发生实际的删除操作。仅当实体的关联映射将DeleteOnNull设置为true且CanBeNull 为false 时，才会发生推理删除行为。  

12.2、使用Attach更新(Update with Attach)

说明：在对于在不同的DataContext之间，使用Attach方法来更新数据。例如在一个名为tempdb的NorthwindDataContext中，查询出Customer和Order，在另一个NorthwindDataContext中，Customer的地址更新为123 First Ave，Order的CustomerID 更新为CHOPS。

//通常，通过从其他层反序列化 XML 来获取要附加的实体
//不支持将实体从一个DataContext附加到另一个DataContext
//因此若要复制反序列化实体的操作，将在此处重新创建这些实体Customer c1;
List<Order> deserializedOrders = new List<Order>();
Customer deserializedC1;using (NorthwindDataContext tempdb = new NorthwindDataContext())
{
    c1 = tempdb.Customers.Single(c => c.CustomerID == "ALFKI");
    deserializedC1 = new Customer
    {
        Address = c1.Address,
        City = c1.City,
        CompanyName = c1.CompanyName,
        ContactName = c1.ContactName,
        ContactTitle = c1.ContactTitle,
        Country = c1.Country,
        CustomerID = c1.CustomerID,
        Fax = c1.Fax,
        Phone = c1.Phone,
        PostalCode = c1.PostalCode,
        Region = c1.Region
    };
    Customer tempcust = tempdb.Customers.Single(c => c.CustomerID == "ANTON");
    foreach (Order o in tempcust.Orders)
    {
        deserializedOrders.Add(new Order
        {
            CustomerID = o.CustomerID,
            EmployeeID = o.EmployeeID,
            Freight = o.Freight,
            OrderDate = o.OrderDate,
            OrderID = o.OrderID,
            RequiredDate = o.RequiredDate,
            ShipAddress = o.ShipAddress,
            ShipCity = o.ShipCity,
            ShipName = o.ShipName,
            ShipCountry = o.ShipCountry,
            ShippedDate = o.ShippedDate,
            ShipPostalCode = o.ShipPostalCode,
            ShipRegion = o.ShipRegion,
            ShipVia = o.ShipVia
        });
    }
}
using (NorthwindDataContext db2 = new NorthwindDataContext())
{
    //将第一个实体附加到当前数据上下文，以跟踪更改
    //对Customer更新，不能写错    db2.Customers.Attach(deserializedC1);
    //更改所跟踪的实体
    deserializedC1.Address = "123 First Ave";
    //附加订单列表中的所有实体    
    db2.Orders.AttachAll(deserializedOrders);
    //将订单更新为属于其他客户
    foreach (Order o in deserializedOrders)
    {
        o.CustomerID = "CHOPS";
    }
    //在当前数据上下文中提交更改    db2.SubmitChanges();
}

语句描述：从另一个层中获取实体，使用Attach和AttachAll将反序列化后的实体附加到数据上下文，然后更新实体。更改被提交到数据库。

12.3、使用Attach更新和删除(Update and Delete with Attach)

说明：在不同的DataContext中，实现插入、更新、删除。看下面的一个例子：

//通常，通过从其他层反序列化XML获取要附加的实体
//此示例使用 LoadWith 在一个查询中预先加载客户和订单，
//并禁用延迟加载
Customer cust = null;using (NorthwindDataContext tempdb = new NorthwindDataContext())
{
    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 = new NorthwindDataContext())
{

    //将第一个实体附加到当前数据上下文，以跟踪更改    
    db2.Customers.Attach(cust);
    //附加相关订单以进行跟踪; 否则将在提交时插们  
    db2.Orders.AttachAll(cust.Orders.ToList());
    //更新客户的Phone.
    cust.Phone = "2345 5436";
    //更新第一个订单OrderA的ShipCity.
    orderA.ShipCity = "Redmond";
    //移除第二个订单OrderB.    cust.Orders.Remove(orderB);
    //添加一个新的订单Order到客户Customer中.
    Order orderC = new Order() { ShipCity = "New York" };
    cust.Orders.Add(orderC);
    //提交执行    
    db2.SubmitChanges();
}

语句描述：从一个上下文提取实体，并使用 Attach 和 AttachAll 附加来自其他上下文的实体，然后更新这两个实体，删除一个实体，添加另一个实体。更改被提交到数据库。

13、并发控制和事务

在 LINQ to SQL 对象模型中，当以下两个条件都得到满足时，就会发生“开放式并发冲突”：客户端尝试向数据库提交更改；数据库中的一个或多个更新检查值自客户端上次读取它们以来已得到更新。 此冲突的解决过程包括查明对象的哪些成员发生冲突，然后决定您希望如何进行处理。

13.1、开放式并发(Optimistic Concurrency)

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

//我们打开一个新的连接来模拟另外一个用户
NorthwindDataContext otherUser_db = new NorthwindDataContext();
var otherUser_product = otherUser_db.Products.First(p => p.ProductID == 1);
otherUser_product.UnitPrice = 999.99M;
otherUser_db.SubmitChanges();
//我们当前连接
var product = db.Products.First(p => p.ProductID == 1);
product.UnitPrice = 777.77M;
try
{
    db.SubmitChanges();
    //当前连接执行成功
}
catch (ChangeConflictException)
{

}

说明：我们读取数据之后，另外一个用户获取并提交更新了这个数据，这时，我们更新这个数据时，引起了一个并发冲突。系统发生回滚，允许你可以从数据库检索新更新的数据，并决定如何继续进行您自己的更新。

//当前用户
var product = db.Products.First(p => p.ProductID == 1);
//我们打开一个新的连接来模拟另外一个用户
NorthwindDataContext otherUser_db = new NorthwindDataContext() ;
var otherUser_product = otherUser_db.Products.First(p => p.ProductID == 1);
otherUser_product.UnitPrice = 999.99M;
otherUser_db.SubmitChanges();//当前用户修改
product.UnitPrice = 777.77M;try
{
    db.SubmitChanges();
}
catch (ChangeConflictException)
{
    //发生异常！
}

13.2、Transactions事务

LINQ to 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 提交本地事务并返回。

13.2.1、Implicit（隐式）

说明：这个例子在执行SubmitChanges()操作时，隐式地使用了事务。因为在更新2种产品的库存数量时，第二个产品库存数量为负数了,违反了服务器上的 CHECK 约束。这导致了更新产品全部失败了，系统回滚到这个操作的初始状态。

try
{
    Product prod1 = db.Products.First(p => p.ProductID == 4);
    Product prod2 = db.Products.First(p => p.ProductID == 5);
    prod1.UnitsInStock -= 3;
    prod2.UnitsInStock -= 5;//错误:库存数量的单位不能是负数
    //要么全部成功要么全部失败    
    db.SubmitChanges();
}
catch (System.Data.SqlClient.SqlException e)
{
    //执行异常处理
}

13.2.2、Explicit（显式）

说明：这个例子使用显式事务。通过在事务中加入对数据的读取以防止出现开放式并发异常，显式事务可以提供更多的保护。如同上一个查询中，更新 prod2 的 UnitsInStock 字段将使该字段为负值，而这违反了数据库中的 CHECK 约束。这导致更新这两个产品的事务失败，此时将回滚所有更改。 

using (TransactionScope ts = new TransactionScope())
{
    try
    {
        Product prod1 = db.Products.First(p => p.ProductID == 4);
        Product prod2 = db.Products.First(p => p.ProductID == 5);
        prod1.UnitsInStock -= 3;
        prod2.UnitsInStock -= 5;//错误:库存数量的单位不能是负数        
        db.SubmitChanges();
    }
    catch (System.Data.SqlClient.SqlException e)
    {
        //执行异常处理    
    }
}