LINQ之路10：LINQ to SQL 和 Entity Framework（下）

在本篇中，我们将接着上一篇“LINQ to SQL 和 Entity Framework（上）”的内容，继续使用LINQ to SQL和Entity Framework来实践“解释查询”，学习这些技术的关键特性。我们在此关注的是LINQ to SQL和Entity Framework中的”LINQ”部分，并会比较这两种技术的相同和不同之处。通过我们之前介绍的LINQ知识还有将来会讨论的更多LINQ Operators，相信阅者能针对LINQ to SQL和Entity Framework写出优雅高效的查询。为了简单清晰，文中有些地方对LINQ to SQL和Entity Framework进行了缩写，分别为：L2S和EF。

LINQ to SQL和Entity Framework的延迟执行

和本地查询一样，L2S和EF查询也是延迟执行的，这样就允许我们渐进地创建LINQ查询。但是，有一个方面，L2S和EF有自己特殊的延迟执行语义，这就是当一个子查询出现在Select表达式中时：

• 对于本地查询，你获得了两个延迟执行，因为从功能角度来看，你选择了包含多个查询的一个sequence。若以当你遍历外层结果sequence时，并不会遍历内部子查询，所以子查询此时也就不会执行。
• 而对于L2S/EF，子查询和外层的主查询在同一时间被执行，这样就避免了过度的连接远程数据库导致性能问题。

比如，对于L2S/EF，下面的查询在第一个foreach语句时执行，且只执行一次：

            var context = new LifePoemContext("database connection string");

            var query = from c in context.Customers
                        select
                            from o in context.Orders
                            select new { c.Name, o.Price };
 
            foreach (var customerOrders in query)
                foreach (var namePrice in customerOrders)
                    Console.WriteLine(namePrice.Name + " spent " + namePrice.Price);

换句话说，我们在select表达式中明确指定的EntitySets/EntityCollections总是在一次执行中就能被获取到：

            var context = new LifePoemContext("database connection string");
            var query = from c in context.Customers
                        select new { c.Name, c.Orders };
 
            foreach (var row in query)
                foreach (var order in row.Orders)   // 没有额外的连接查询
                    Console.WriteLine(row.Name + " spent " + order.Price);

但如果我们没有事先进行数据转换，就对EntitySet/EntityCollection属性进行遍历的话，就会适用于延迟执行。下面的示例中，L2S和EF在每一次循环中都会执行另外的Orders查询：

            context.ContextOptions.DeferredLoadingEnabled = true;   // 仅EF需要此句
 
            foreach (Customer c in context.Customers)
                foreach (Order o in c.Orders)   // 每次都会开始一个新的SQL查询
                    Console.WriteLine(c.Name + " spent " + o.Price);

这种模式在我们需要有条件的执行内部查询时具有优势，比如我们可能需要依靠客户端来做某个条件测试时：

            foreach (Customer c in context.Customers)
                if(myWebService.HasBadCreditHistory(c.ID))
                    foreach (Order o in c.Orders)   // 开始一个新的SQL查询
                        Console.WriteLine(c.Name + " spent " + o.Price);

上面我们看到了如何对关联属性进行显示的数据转换（select）来避免重复执行。稍后我们就会看到，L2S和EF还提供了其他的机制来实现这个功能。

DataLoadOptions

DataLoadOptions类是L2S的特性，它有两个特殊的作用：

• AssociateWith让你能够事先对EntitySet关联设置过滤条件
• LoadWith让你能够设置某些EntitySets为主动加载（eager loading），从而减少连接数据库的次数

设置过滤条件

假如我们只关心那些Price大于1000的Orders，我们就可以通过DataLoadOptions来设置过滤条件：

            var context = new LifePoemContext("database connection string");
 
            DataLoadOptions options = new DataLoadOptions();
            options.AssociateWith<Customer>(c => c.Orders.Where(order => order.Price > 1000));
            context.LoadOptions = options;
 
            foreach (Customer c in context.Customers)
                if (myWebService.HasBadCreditHistory(c.ID))
                    ProcessCustomer(c); // 如果在该方法中引用c.Orders，只有那些Price > 1000的Orders被返回

这会指示我们的DataContext实例总是使用给定的条件对Customer的Orders进行过滤。需要注意的是，AssociateWith并不会改变延迟执行的语义，它只是命令对特定的关系进行隐式的过滤。

主动加载(Eager Loading)

DataLoadOptions的第二个作用是请求让某个EntitySets跟随父EntitySets一起加载。比如，假设你想在加载所有Customers的同时一起加载他们的Orders，而不是对每一个Customer分别查询一次Orders：

            var context = new LifePoemContext("database connection string");
 
            DataLoadOptions options = new DataLoadOptions();
            options.LoadWith<Customer>(c => c.Orders);
            context.LoadOptions = options;
 
            foreach (Customer c in context.Customers)    // 一次查询
                foreach (Order o in c.Orders)            // 因为上面的DataLoadOptions，所有的Orders都在上面的查询中被同时Load了
                    Console.WriteLine(c.Name + " bought a " + o.Description);

这会指示DataContext，不论何时，只要一个Customer被获取，它的Orders也会在同一时间被加载。我们可以组合LoadWith和AssociateWith方法，这样既能获得主动加载，还能对加载的EntitySets进行过滤，比如：

            DataLoadOptions options = new DataLoadOptions();
            options.LoadWith<Customer>(c => c.Orders);
            options.AssociateWith<Customer>(c => c.Orders.Where(order => order.Price > 1000));

Entity Framework中的主动加载（Eager Loading）

在Entity Framework中，如果我们希望某个关联的EntitySets被主动加载，则可以使用Include方法。下面的代码就是在一个SQL查询中，获取所有的Customers和他们的Orders：

            foreach (var c in context.Customers.Include("Orders"))
                foreach (var order in c.Orders)
                    Console.WriteLine(order.Description);

Include可以被级联使用，假如每个Order都有OrderDetails和SalesPersons导航属性的话，我们可以写出如下的查询让这些数据也被一同加载：

            context.Customers.Include("Orders.OrderDetails")
                             .Include("Orders.SalesPersons")

更新

L2S和EF也会跟踪你对Entities所做的修改并允许你把他们更新到数据库。对于L2S，我们调用DataContext对象的SubmitChanges方法；而对于EF，我们调用ObjectContext对象的SaveChagnes方法。

L2S的Table<>类提供了InsertOnSubmit和DeleteOnSubmit方法让我们从一个表中插入或删除行；EF的ObjectSet<>类则提供了AddObject和DeleteObject方法来实现相同的功能，请看下面的代码示例：

            var context = new LifePoemContext("database connection string");
 
            Customer cust = new Customer { ID = 1000, Name = "Yoyoo" };
            context.Customers.InsertOnSubmit(cust);     // 插入Customer，在EF中使用AddObject
            context.SubmitChanges();                    // 在EF中使用SaveChanges
 
            // 现在我们获取上面插入的数据行，对其进行更新，然后删除它
            Customer cust2 = context.Customers.Single(c => c.ID == 1000);
            cust2.Name = "Yoyoo2";
            context.SubmitChanges();                    // 更新Customer
 
            context.Customers.DeleteOnSubmit(cust2);    //在EF中使用DeleteObject
            context.SubmitChanges();                    // 删除Customer

SubmitChanges/SaveChanges会收集自context创建（或上一次Save）以来对entities所做的所有修改，然后执行一个SQL语句来把他们写回数据库。

我们还可以调用Add方法来向一个EntitySet/EntitiyCollection添加数据行，在执行SubmitChanges或SaveChanges，L2S和EF会自动生成相应的外键：

            Order o1 = new Order { ID = 100, OrderDate = DateTime.Now, Price = 100 };
            Order o2 = new Order { ID = 101, OrderDate = DateTime.Now, Price = 500 };
 
            Customer cust = context.Customers.Single(c => c.ID == 1);
            cust.Orders.Add(o1);
            cust.Orders.Add(o2);
 
            context.SubmitChanges();

在这个例子中，L2S/EF会自动把外键值1写入新增的Order的CustomerID列，这是因为我们为Customer和Order定义了关联属性，如：

        // With L2S
        [Association(Name="Customer_Order", Storage="_Orders", ThisKey="ID", OtherKey="CustomerID")]
        public EntitySet<Order> Orders { get {...} set {...} }

当你从一个EntitySet/EntityCollection中移除某行数据时，他的外键列会被自动设置为null。下面的代面会在我们最近新增的两个orders和他们的Customer之间移除关联，注意，只是去除关联，Remove并不会删除子entities：

            var context = new LifePoemContext("database connection string");
 
            Customer cust = context.Customers.Single(c => c.ID == 1);
            cust.Orders.Remove(cust.Orders.Single(order => order.ID == 100));
            cust.Orders.Remove(cust.Orders.Single(order => order.ID == 101));
 
            context.SubmitChanges();

因为上面的代码会把每个Order的CustomerID列设为空，所以数据库中Order.CustomerID列必需是可空的，否则会抛出异常。

如果我们要完全删除子entities，则需要调用DeleteOnSubmit：

            // with L2S
            context.Orders.DeleteOnSubmit(context.Orders.Single(order => order.ID == 100));
            context.Orders.DeleteOnSubmit(context.Orders.Single(order => order.ID == 101));
            context.SubmitChanges();
 
            // with EF
            context.Orders.DeleteObject(context.Orders.Single(order => order.ID == 100));
            context.Orders.DeleteObject(context.Orders.Single(order => order.ID == 101));
            context.SaveChanges();

LINQ to SQL和Entity Framework的API对比

正如我们在这两篇文章中看到的那样，L2S和EF在LINQ查询和数据更新方面非常相似，只是创建的对象或调用的方法有所不同罢了，下表总结了他们的API差异： 

目的	LINQ to SQL	Entity Framework
获取保持所有CRUD操作的类	DataContext	ObjectContext
从数据库中（延迟）获取某种类型的所有entities	GetTable	CreateObjectSet
上面方法的返回类型	Table<T>	ObjectSet<T>
提交对实体对象的更新	SubmitChanges	SaveChanges
新增一个entity	InsertOnSubmit	AddObject
删除一个entity	DeleteOnSubmit	DeleteObject
代表关联属性（有多个相关entities的那一方）的类型	EntitySet<T>	EntityCollection<T>
代表关联属性（有多个相关entities的那一方）的类型（字段类型）	EntityRef<T>	EntityReference<T>
装载关联属性时的默认策略	自动延迟加载	明确调用
主动加载(eager loading)	DataLoadOptions	.Include()

通过这两篇文章，我们有针对性的了解了L2S和EF在LINQ查询支持上的特性。通过比较他们的异同，让我们更好的他们的内在联系和区分他们在使用上的差别。在接下来的几篇博客中，我准备对LINQ查询运算符（LINQ Operators）进行更加详细的分类介绍。只有在了解了大多数查询运算符后，才能更好的写出功能强大而又简洁优雅的 LINQ查询。