Lazy loading when using Single and SingleOrDefaultAsync - entity-framework

Question

I have two data models
ApplicationUser and Team
public class Team : OwnerEntity
{
public virtual ICollection<ApplicationUser> Members { get; set; } = new HashSet<ApplicationUser>();
public int MaxTeamSize { get; set; }
public string TeamName { get; set; }
public virtual ICollection<Project> Projects { get; set; }
public string AvatarUri { get; set; }
public Team(string teamName, int teamSize)
{
TeamName = teamName;
MaxTeamSize = teamSize;
}
public Team()
{
}
}
public class ApplicationUser : IdentityUser
{
public virtual ICollection<Team> Teams { get; set; } = new HashSet<Team>();
[ForeignKey("ActiveTeamId")]
public string ActiveTeamId { get; set; }
public virtual Team ActiveTeam { get; set; }
}
I noticed behaviour that I cannot understand when I use
var teams = db.Teams.Single();
I get the team without Members, and that is correct. However when I use
await db.Teams.SingleOrDefaultAsync(_ => _.Id == UserTeamId);
It always returns Members event though I did not include it anywhere with
db.Teams.Inlclude(_ => _.Members)
Also calling one after another
public async Task<IActionResult> TEst()
{
var teams = db.Teams.Single();
var querySingle = await db.Teams.SingleOrDefaultAsync(_ => _.Id == UserTeamId);
return new JsonResult(querySingle);
}
Results in teams.Single() also returns a list of members. I think I do not fully understand LazyLoading mechanism. Can someone explain this case?

Answer 1

With EF Core you need to enable lazy loading proxies before lazy loading will function. The easiest way to observe lazy load calls is with a profiler running against a test DB that is not being accessed by anything but your code under test.
If lazy loading is not enabled, EF's behaviour will associate any tracked entities it has references to. For example, given a Parent (ID 1) with 3 Children (IDs 1, 2, & 3) If at some point we load the children:
var children = context.Children.Where(x => x.ParentId == 1);
... then later load the parent:
var parent = context.Parents.Single(x => x.ParentId == 1);
var count = parent.Children.Count; // returns 3.
... you can access parent.Children and you will receive the 3 children even though you did not eager load them. The DbContext was tracking the references so it populated them. This can be rather dangerous situationally because take the following example:
var child = context.Children.Single(x => x.ChildId == 3);
var parent = context.Parents.Single(x => x.ParentId == 1);
var count = parent.Children.Count; // returns 1.
parent.Children will be populated here, but will only contain Child #3 if that is the only child the DbContext was tracking.
I would highly suspect that lazy loading is not actually enabled in your project. To test whether lazy loading is actually working, I would instantiate a new DbContext with the following check, watching a profiler for SQL hits:
using (var context = new AppDbContext()) // Your app context here.
{
var parent = context.Parents.Single(x => x.ParentId == 1); // load a single parent.
var count = parent.Children.Count; // <- breakpoint on this line.
}
Hit the breakpoint and watch the profiler. After you step over the line, did an SQL query get executed? Note even if you hover over Children in the debugger, this would trigger the lazy load proxy in most cases. (or generate a warning that threads need to execute) If count comes back with the # of children then that confirms lazy loading is configured properly. If it comes back as "0" then lazy loading isn't enabled.
For EF Core you need to include the EntityFrameworkCore.Proxies NuGet package and initialize the optionsBuilder in the DbContext .OnConfiguring handler to enable lazy loading proxies:
optionsBuilder.UseLazyLoadingProxies();
Then the tracked references for the Children collection are ignored and a lazy load call will be made.
var child = context.Children.Single(x => x.ChildId == 3);
var parent = context.Parents.Single(x => x.ParentId == 1);
var count = parent.Children.Count; // returns 3. Lazy load SQL call observed.
I tried this out with both Sync and Async calls and there was no observed difference. I suspect the behaviour you were seeing was that lazy loading isn't actually enabled and you are making an async call sometime after the DbContext has already loaded the associated children. That a call to the DbContext can return children without eager loading sometimes and not others can be a rather confusing and bug-prone behaviour. If lazy loading is configured correctly and active it should return more reliable results but I treat it more as a failsafe rather than designing for it. It's generally always better to leverage eager loading and projection to load data rather than relying on lazy loading.