Is there any way to disable lazy loading for specific query on Entity Framework 6? I want to use it regularly, but sometimes I want to disable it. I'm using virtual properties to lazy load them.
9 Answers
set the following code before the query you want to execute
context.Configuration.LazyLoadingEnabled = false;
1 Comment
Nissim Elbaz
I think in EF code first, it won't work. You will need to not declare the collection to be
virtual, and then use include() whenever you want the loading to be non-lazy. Don't forget to add using System.Data.Entity;You can disable Lazy loading for a specific query as follows :
public static Cursos GetDatosCursoById(int cursoId)
{
using (var bd = new AcademyEntities())
{
try
{
bd.Configuration.ProxyCreationEnabled = false;
return bd.Cursos.FirstOrDefault(c => c.cursoId == cursoId);
}
catch (Exception ex)
{
return null;
}
}
}
Comments
I might be missing something here, but rather than changing the configuration each time, might another approach be to use .Include() on only those queries where you want to eager load?
Suppose we have a Product class which has a navigation property to a Colour class, you might load the Colour for a Product like this -
var product = _context.Products
.Where(p => p.Name == "Thingy")
.Include(x => x.Colours)
.ToList();
7 Comments
Ian
For me this is the best Answer here!
Mackan
This falls short if you only want to eager load "products", without any includes.
Parrybird
So you'd want to get 'Products' without any of their related objects, or 'Products with all their related objects?'
Richard Petheram
Much more useful answer. This controls the specific sub-ordinate tables that are loaded at the point where the query is being constructed. For any real world problem this has to be the way to go.
Doug
It is useful in a different way... if you do it this way one could still get lazy loading for another collection from 'Products'. Actually disabling lazy loading is more effective to guarantee that all data needed is fetched in advance and avoids creating hidden performance bottlenecks.
|
In EF Core: context.ChangeTracker.LazyLoadingEnabled = false;
Per this answer.
2 Comments
Gert Arnold
It would be useful to mention here that lazy loading never occurs in EF core unless it's explicitly configured. Then it can be switched off in individual cases.
Cameron Castillo
The EF Core code also works when your EF project is .Net Framework.
Go to your diagram properties and find a property designated to lazy loading and disable it.
If you are using code first then go to your config area and disable it from there with:
this.Configuration.LazyLoadingEnabled = false;
1 Comment
Juan
A lot of people are visiting this question and I want to say, people DONT WRITE QUERIES WITH OUT TAKING A LOOK TO THE EXECUTION PLAN. Always know what your code send to the database or you will have performance problems. You can use linq pad or other tools to view the real query and check.
Another approcah for another EF Version (Entity Framework 5)
//Note: ContextOptions instead of ChangeTracker or Configuration
context.ContextOptions.LazyLoadingEnabled = false;
Comments
Suppose you have this:
IOrderedQueryable<Private.Database.DailyItem> items;
using (var context = new Private.Database.PrivateDb())
{
context.Configuration.LazyLoadingEnabled = false;
items = context.DailyItem.OrderBy(c => c.sortOrder).OrderByDescending(c => c.isFavorite);
}
You'd still get lazy loading, despite the explicit setting of not to. The fix is easy, change it to this:
List<Private.Database.DailyItem> items;
using (var context = new Private.Database.PrivateDb())
{
// context.Configuration.LazyLoadingEnabled = false;
items = context.DailyItem.OrderBy(c => c.sortOrder).OrderByDescending(c => c.isFavorite).ToList();
}
Comments
For EF Core to make it simple with a method you can use this helper:
public static AppDbContext DisableLazyLoading(this AppDbContext dbcontext)
{
dbcontext.ChangeTracker.LazyLoadingEnabled = false;
return dbcontext;
}
Using
return dbcontext.DisableLazyLoading().Branches.Find(course.BranchId);
1 Comment
Gert Arnold
See my comment above. It's not really useful to disable lazy loading only to execute a query. This method strongly suggests that that is exactly what happens (because it's fluent, it looks like
AsNoTracking, which does change behavior for one query). In reality, it just executes the query exactly as it would with LL enabled, but it turns LL off on the context for the rest of its lifetime. The way it can be used is deceptive.i just do this in every class that need disable lazy loading and in every class just call the db without lazyloading everything work fine
private DataContext db;
public TheClass ()
{
db = new DataContext(ConString);
db.Configuration.LazyLoadingEnabled = false;
}
this.Configuration.LazyLoadingEnabled = false;, then set it againthis.Configuration.LazyLoadingEnabled = true;? Also, you can read this msdn.microsoft.com/en-us/data/jj574232.aspx