Lazy loading in Entity Framework is the default phenomenon that happens for loading and accessing the related entities. However, eager loading is referred to the practice of force-loading all these relations. I have come across the question of under what situation eager loading could be more beneficial than lazy loading. Asking this, because it is obvious that lazy loading is more resource friendly, and even if we use the ToList()
method, we can still take advantage of the lazy loading behavior. However, I thought maybe lazy loading increases the number of requests to the actual database and maybe that's why sometimes developers use the Inlcude
method to force-loading all relations. For example, when using the Visual Studio auto-scaffolding in MVC 5, the Index method that is automatically created in the controller always uses Eager Loading, and I've always had the question of why Microsoft uses Eager Loading by default in that case.
I would appreciate if someone explains to me under what situation eager loading would be more beneficial than lazy loading, and why do we use it at all while there's something more resource friendly as Lazy Loading.
This question is related to
c#
entity-framework
entity-framework-6
// Using LINQ and just referencing p.Employer will lazy load
// I am not at a computer but I know I have lazy loaded in one
// query with a single query call like below.
List<Person> persons = new List<Person>();
using(MyDbContext dbContext = new MyDbContext())
{
persons = (
from p in dbcontext.Persons
select new Person{
Name = p.Name,
Email = p.Email,
Employer = p.Employer
}).ToList();
}
Lazy loading will produce several SQL calls while Eager loading may load data with one "more heavy" call (with joins/subqueries).
For example, If there is a high ping between your web and sql servers you would go with Eager loading instead of loading related items 1-by-1 with lazy Loading.
It is better to use eager loading when it is possible, because it optimizes the performance of your application.
ex-:
Eager loading
var customers= _context.customers.Include(c=> c.membershipType).Tolist();
lazy loading
In model customer has to define
Public virtual string membershipType {get; set;}
So when querying lazy loading is much slower loading all the reference objects, but eager loading query and select only the object which are relevant.
Eager Loading: Eager Loading helps you to load all your needed entities at once. i.e. related objects (child objects) are loaded automatically with its parent object.
When to use:
Lazy Loading: In case of lazy loading, related objects (child objects) are not loaded automatically with its parent object until they are requested. By default LINQ supports lazy loading.
When to use:
NOTE: Entity Framework supports three ways to load related data - eager loading, lazy loading and explicit loading.
Lazy loading - is good when handling with pagination like on page load list of users appear which contains 10 users and as the user scrolls down the page an api call brings next 10 users.Its good when you don't want to load enitire data at once as it would take more time and would give bad user experience.
Eager loading - is good as other people suggested when there are not much relations and fetch entire data at once in single call to database
Consider the below situation
public class Person{
public String Name{get; set;}
public String Email {get; set;}
public virtual Employer employer {get; set;}
}
public List<EF.Person> GetPerson(){
using(EF.DbEntities db = new EF.DbEntities()){
return db.Person.ToList();
}
}
Now after this method is called, you cannot lazy load the Employer
entity anymore. Why? because the db
object is disposed. So you have to do Person.Include(x=> x.employer)
to force that to be loaded.
Eager Loading When you are sure that want to get multiple entities at a time, for example you have to show user, and user details at the same page, then you should go with eager loading. Eager loading makes single hit on database and load the related entities.
Lazy loading When you have to show users only at the page, and by clicking on users you need to show user details then you need to go with lazy loading. Lazy loading make multiple hits, to get load the related entities when you bind/iterate related entities.
Source: Stackoverflow.com