EntityFramework(EF)贪婪加载和延迟加载的选择和使用

贪婪加载：顾名思议就是把所有要加载的东西一 次性读取

1 using (var context = new MyDbContext())
2 {
3     var orders = from o in context.Orders.Include("OrderDetails") select o;
4 }

当读取订单信息orders的时候，我们希望把订单的详细信息也读取出来，那么这里我们使用Include关键字将关联表也加载进 来。

延迟加载：即当我们需要用到的时候才进行加载（读取）

当我们希望浏览某条订单信息的时候，才显示其对应的订单详细记录时，我们希望使用延迟加载来实现，这样不仅加快的了 读取的效率，同时也避免加载不需要的数据。延迟加载通常用于foreach循环读取数据时。

那么我们在定义Model的时候，需要在属性前面添加virtual关键字。如下

1 public class Order
2 {
3     public int OrderID { get; set; }
4     public string OrderTitle { get; set; }
5     public string CustomerName { get; set; }
6     public DateTime TransactionDate { get; set; }
7     public virtual List<OrderDetail> OrderDetails { get; set; }
8 } 

如果我们想要禁止使用延迟加载，那么最好的方法是在DbContext类的构造方法中声明

1 public class MyDbContext:DbContext
2 {
3     public MyDbContext()
4     {
5         this.Configuration.LazyLoadingEnabled = false;
6     }
7 }

总结：

贪婪加载： 1、减少数据访问的延迟，在一次数据库的访问中返回所有的数据。 2、一次性读取所有相关的数据，可能导致部分数据实际无需用到，从而导致读取数据的速度变慢，效率变低

延迟加载： 1、只在需要读取关联数据的时候才进行加载 2、可能因为数据访问的延迟而降低性能，因为循环中，每一条数据都会访问一次数据库，导致数据库的压力加大

综上所述，我们应该比较清楚时候应该使用哪种机制？我个人的建议是：

1、如果是在foreach循环中加载数据，那么使用延迟加载会比较好， 因为不需要一次性将所有数据读取出来，这样虽然有可能会造成n次数据库的查询，但 是基本上在可以接受的范围内。

2、如果在开发时就可以预见需要一次性加载所有的数据，包含关联表的所有数据， 那么使用使用贪婪加载是比较好的选择，但是此种方式会导致效率问题，特别是数据量大的情况下。

两张表:订单表（Order_Info）和产品表（Order_Detail）

订单表:包含2条订单

产品表:4件产品，分别属于上面两个订单

优化一

问题：查询每件产品属于哪个订单时，需要连接几次数据库？

     本应该查询4次，EF做了优化后，查询2次。

1. public static void QueryUser()
2. {
3. IQueryable<Order_Detail>query = db.Order_Detail.Where(a => a.OrderID>0);
4. foreach (Order_Detail detail inquery)
5. {
6. Console.WriteLine("产品" + detail.ProductName
7. + ",所属订单" + detail.Order_Info.OrderID);
8. }
9. }

     public static void QueryUser()
    {
            IQueryable<Order_Detail>query = db.Order_Detail.Where(a => a.OrderID>0);

            foreach (Order_Detail detail inquery)
            {
                Console.WriteLine("产品" + detail.ProductName
                 + ",所属订单" + detail.Order_Info.OrderID);
            }
    }
    

为什么查询了2次？

当他发现4条产品的订单号有重复的时候,他就读取他自己的缓存数据,就不读取数据库里面的数据里，这是EF做的一个小优化。

优化二  include进行inner join查询

虽然EF为我们做了优化一，那当我们有1000个产品时，即使读取又重复的产品，那也需要去读1000次。之前我们只需要一个inner join就可以一次性读取出来。

1. //这里的include需要加载的文字,是从 Orderil_Detail的表结构里面订单的属性名字来复制的,注意是属性名字,而不是属性的类
2. IQueryable<Order_Detail>query = db.Order_Detail.Include("Order_Info").Where(a =>a.OrderID>0);
3. foreach (Order_Detail detail inquery)
4. {
5. Console.WriteLine("产品" + detail.ProductName
6. + ",所属订单" + detail.Order_Info.OrderID);
7. }

           //这里的include需要加载的文字,是从 Orderil_Detail的表结构里面订单的属性名字来复制的,注意是属性名字,而不是属性的类
            IQueryable<Order_Detail>query = db.Order_Detail.Include("Order_Info").Where(a =>a.OrderID>0);

            foreach (Order_Detail detail inquery)
            {
                Console.WriteLine("产品" + detail.ProductName
                 + ",所属订单" + detail.Order_Info.OrderID);
            }

通过使用include，我们可以实现查询一次数据库即可，相当于之前的inner join。如果关联多个表，可以使用多个include进行关联。