Why should I use `.Include(...)` to include navigation properties? - entity-framework

Question

Why should I put .Include(...) while the view has visibility on all navigation properties?
action1
public ActionResult Included(){
var models = db.Money.Include(m=>m.Rate);
return View(models);
}
action2
public ActionResult UnIncluded(){
var models = db.Money;
return View(models);
}
In both views I may get the amount as follows
#Html.DisplayFor(model=>model.Rate.Amount)
So, what is the difference?
Is this what we know as lazy load mode?

Answer 1

So, what is the difference? Is this what we know as lazy load mode?
Yes.
Assume your Money table has 1000 rows. Also assuming that Rate is a navigation property, the following will execute 1001 separate SQL queries:
public ActionResult UnIncluded(){
var models = db.Money;
return View(models);
}
...
#Html.DisplayFor(model=>model.Rate.Amount)
Why? The above action will return only the Money data to the view. Then the view, while iterating over each Money instance, will lazily load each and every .Rate instance. This means 1000 extra SQL queries, one for each Money item in the collection.
However, the following will only execute 1 SQL query:
public ActionResult Included(){
var models = db.Money.Include(m=>m.Rate);
return View(models);
}
...
#Html.DisplayFor(model=>model.Rate.Amount)
Why? The above action will execute a single SQL query that performs a JOIN between the Money and Rate tables to load all of the Rate data for each of the 1000 Money rows in only one round trip to the database. This is known as eager-loading.
As #IronMan84 says, this is assuming that you have lazy loading enabled, and that Rate is a virtual navigation property on Money.

Answer 2

.Include forces the specified property to be loaded eagerly, as opposed to lazily, assuming that lazy loading is turned on in your application. So in your first action Rate will have been brought back from the database right away, as opposed to your second action in which it will only be brought over (again, assuming lazy loading is on) when it's called for (i.e. when you call for model.Rate.Amount on the page).
One thing that you should be aware of: If you're using lazy loading, it would actually behoove you to use .Include or to use .ToList() in your controller action, because you could possibly run into situations in which you get an exception because your controller has disposed the DbContext object before the View calls for a navigational property that requires EF to go back to the database. So Action1 above might be the better way to go just to avoid that situation.
MSDN post on Include can be found here.