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的信息。其实看到这里大家就知道了贪婪加载虽然没有在循环中那么的消耗性能，但是一次性查询的数据是很多的，还是有影响的，但是没有懒加载那么厉害了。

总结一下，如果要在循环中使用数据，请使用贪婪加载，否则使用懒加载。