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 }

 

 

总结：

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

延迟加载： 一、只在须要读取关联数据的时候才进行加载 二、可能由于数据访问的延迟而下降性能，由于循环中，每一条数据都会访问一次数据库，致使数据库的压力加大

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

一、若是是在foreach循环中加载数据，那么使用延迟加载会比较好， 由于不须要一次性将全部数据读取出来，这样虽然有可能会形成n次数据库的查询，但 是基本上在能够接受的范围内。

二、若是在开发时就能够预见须要一次性加载全部的数据，包含关联表的全部数据， 那么使用使用贪婪加载是比较好的选择，可是此种方式会致使效率问题，特别是数据量大的状况下。

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

         订单表:包含2条订单

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

 

优化一  

  问题：查询每件产品属于哪一个订单时，须要链接几回数据库？

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

 

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

     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就能够一次性读取出来。

 

//这里的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须要加载的文字,是从 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进行关联。