EF中的贪婪加载和延迟加载（懒加载）

在上一章中，咱们使用了Linq对Entity Framework进行了一个查询，可是经过学习咱们却发现了懒加载给我来的性能上的开销是很到的，尤为是在循环中，若是数据量不是不少的状况下还能够接受，若是数据量一旦大气来，那么这个效率则是影响很是大的。那该怎么办呢？其实在Entity Framwork中，除了提供了懒加载技术还提供了一个“贪婪加载”。那么什么是贪婪加载呢？从名字上看，就是很是的粗鲁的，一次性的吧相关的数据所有查询出来，虽然在性能上说仍是有点影响的，可是比起在循环中使用懒加载要强了很多了啊。

下面呢，老魏先不说懒加载的知识，把上一张遗留的一个查询给家说一下，顺便以这个例子和贪婪加载作一下对比。

Demo3:查询班级的信息，还要获得此班级中的学生。

SQL:

select a.* ,b.* from clazz as a left join student as b

on a.CId = b.CId

Linq:

DAL.SchoolContext context = new DAL.SchoolContext();

var query = from clazz in context.Clazz

select clazz;

foreach (var clazz in query)

 {

      Console.WriteLine(clazz.CName);

if (clazz.Students != null && clazz.Students.Count > 0)

  {

         foreach(var student in clazz.Students)

        {

           Console.WriteLine("---该班的学生:" + student.SName);

       }

   }
 }

翻译SQL:在执行中翻译的SQL

这里老魏截图了，就是由于在循环中使用懒加载而产生了n多个查询语句，可是

整体上两个SQL语句：

1，查询出clazz信息的SQL

SELECT 

    [Extent1].[CId] AS [CId], 

    [Extent1].[CName] AS [CName]

    FROM [dbo].[Clazz] AS [Extent1]

2，根据懒加载而产生的SQL语句（被重复了N次）

exec sp_executesql N'SELECT 

    [Extent1].[SId] AS [SId], 

    [Extent1].[SName] AS [SName], 

    [Extent1].[SAge] AS [SAge], 

    [Extent1].[SMail] AS [SMail], 

    [Extent1].[CId] AS [CId]

    FROM [dbo].[Student] AS [Extent1]

    WHERE [Extent1].[CId] = @EntityKeyValue1',N'@EntityKeyValue1 int',@EntityKeyValue1=2

虽然咱们经过懒加载能够达到咱们想要的效果，可是在效率上是没法忍受的尤为是在数据多的状况下。

那么Entity Framework也想到了这问题，由于全部的ORM框架都有懒加载，使用起来的确的方便，可是也是在改用的时候用，尤为在循环中就更不该该使用了。因此这里呢，老魏有个建议，就是在循环中千万不要使用懒加载。既然在循环中不能使用懒加载那么该怎么办呢?这就要利用Entity Framework给咱们提供的贪婪加载。下面看如下代码，而后老魏在来解释一下。把上面的代码改成以下的代码：

DAL.SchoolContext context = new DAL.SchoolContext();

//取消懒加载目的是为了作实验看可以一次加载完数据

context.Configuration.LazyLoadingEnabled = false;

var query = from clazz in context.Clazz.Include("Students")

select clazz;

foreach (var clazz in query)

 {

          Console.WriteLine(clazz.CName);

          if (clazz.Students != null && clazz.Students.Count > 0)

          {

              foreach(var student in clazz.Students)

             {

                Console.WriteLine("---该班的学生:" + student.SName);

              }

         }

}

运行一下，同时监控一下SQL Server的状态。首先是翻译的SQL:

SELECT 

    [Project1].[CId] AS [CId], 

    [Project1].[CName] AS [CName], 

    [Project1].[C1] AS [C1], 

    [Project1].[SId] AS [SId], 

    [Project1].[SName] AS [SName], 

    [Project1].[SAge] AS [SAge], 

    [Project1].[SMail] AS [SMail], 

    [Project1].[CId1] AS [CId1]

    FROM ( SELECT 

        [Extent1].[CId] AS [CId], 

        [Extent1].[CName] AS [CName], 

        [Extent2].[SId] AS [SId], 

        [Extent2].[SName] AS [SName], 

        [Extent2].[SAge] AS [SAge], 

        [Extent2].[SMail] AS [SMail], 

        [Extent2].[CId] AS [CId1], 

        CASE WHEN ([Extent2].[SId] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1]

        FROM  [dbo].[Clazz] AS [Extent1]

        LEFT OUTER JOIN [dbo].[Student] AS [Extent2] ON [Extent1].[CId] = [Extent2].[CId]

    )  AS [Project1]

    ORDER BY [Project1].[CId] ASC, [Project1].[C1] ASC

SQL Server状态：

发如今执行的过程当中，循环语句并无的发出额外的指令，只是用来上面翻译的SQL。可是结果倒是同样的。

无非就是在Linq中加入了一个Include()方法。这个方法就是用来开启贪婪加载的主要方法。意思是说在加载查询对象的时候。把查询对象的关联数据也查询出来。其实这里面是有陷阱的。固然这陷阱值得是Include的参数。顾名思义，和clazz管理的是student对象，那么在参数就是”Student”。其实否则，由于根据Include参数的含义是说“路径”。那么这个路径是什么呢?其实就是”导航属性的名字“。在clazz中有一个导航属性是Students，则在Include中也要使用这个名字。

固然了，若是你们想的到的话，那么和Student关联的对象可以查询出来呢？答案是确定的，若是关联属性有多个则使用”.”来链接。好比咱们能够把代码改成以下的样子：

var query = from clazz in context.Clazz.Include("Students.Student_Courses.Courses")

                select clazz;

那咱们在查询clazz对象的也查出来了student,course的信息。其实看到这里你们就知道了贪婪加载虽然没有在循环中那么的消耗性能，可是一次性查询的数据是不少的，仍是有影响的，可是没有懒加载那么厉害了。

总结一下，若是要在循环中使用数据，请使用贪婪加载，不然使用懒加载。