Entity framework 'include' including more than it should

Question

I have a class Program:

[Table("Program")]
public class Program
{
    [Key]
    public long ProgramId { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public bool IsActive { get; set; }
    public virtual ICollection<Activity> Activities { get; set; }
    public virtual ICollection<User> Users { get; set; }
    public virtual ICollection<TimeEntry> TimeEntries { get; set; }
 }

The typical usage pattern is to grab a Program and all it's associated Activities. Much less often need Programs and their related Users or TimeEntries.

So, to return json of all the programs and their related activities. I used .Include:

//...
var programActivities = db.Programs.Include(p => p.Activities);

As expected the json emitted has programs and nested activities. Good.

But, it also returned each Program's associated TimeEntries and Users. Didn't expect that! Other articles i've read indicate that you use one .Include for each of the related objects to be returned, so it would follow that if you don't use an .include for an object, you don't get it.

Is there an additional switch or option i have to use to exclude the other related objects?

btw... of course, this had db implications as well. the profiler shows it generated two additional dynamic sql selects for each program. — david m chinn, May 14 '15 at 11:22

ocuenca · Answer 1 · 2015-05-14T12:10:32.520

2

Don't declare your navigation properties as virtual or disable Lazy Loading behavior. Lazy loading is enable by default and is achieved by creating instances of derived proxy types and then overriding virtual properties to add the loading hook. So, if you want to work with JSON I recommend you turn off lazy loading:

public class YourContext : DbContext 
{ 
    public YourContext() 
    { 
        this.Configuration.LazyLoadingEnabled = false; 
    } 
}

Now you can load the related entities you want using the Include extension method as part of a query. This behavior is called Eager Loading.

These links can help you to understand better what I explain in my answer:

Loading Related Entities (read the lazy loading section)
Requirements for Creating POCO Proxies

edited May 14 '15 at 12:10

answered May 14 '15 at 11:28

ocuenca

38,548
11
89
102

Thanks octaviocci. I"d read the post, but didn't really understand the part about how lazy loading and serialization works until I read yours and elolos' answer. I just made the navigation properties non-virtual, and now it works as I expect. – david m chinn May 14 '15 at 15:29
@davidmchinn: Exactly, if you remove the `virtual keyword` from your navigation properties, the POCO entity not meet the requirements described in the second link, so, EF won't create a proxy class to lazy load your properties, that's way are not loaded now. But if you disabled lazy loading, even when your navigation properties are `virtual`, they won't be loaded in any entity. It's good idea disable lazy loading when you are using a serializer. Most serializers work by accessing each property on an instance of a type. – ocuenca May 14 '15 at 15:45

elolos · Answer 2 · 2015-05-14T11:32:43.793

In Entity Framework, when using the Include statement like so db.Programs.Include(p => p.Activities), you are basically ensuring that the navigation property will be eagerly loaded, rather than lazy loaded. Essentially, this means using one database query to get the data for a Program and its related Activites rather than two.

The problem is, what if lazy loading is enabled for the context, any attempt to get the rest of the navigation properties will result in extra database calls. This is probably what's happening when the JSON serializer tries to serialize your Program objects.

In order to prevent this, you should probably look for a way to exclude the navigation properties from being serialized and so they will never be loaded from the database. For example:

[JsonIgnore]
public virtual ICollection<User> Users { get; set; }

[JsonIgnore]
public virtual ICollection<TimeEntry> TimeEntries { get; set; }

This will allow you to keep lazy loading on, while preventing the loading of the rest of the properties. It all depends on your application design, for example if you need to use lazy loading or if your navigation properties need to be exposed occasionally.

Entity framework 'include' including more than it should

2 Answers2

Linked