实体框架ObjectQuery.Include（）

Question

I have an object with two objects as properties ( User , PrimaryNode ), both could potentially be null, see below:

public class Item
{
    [Key]
    public int ItemId { get; set; }
    public string ItemName { get; set; }
    public Node PrimaryNode { get; set; }
    public User User { get; set; }
}

I'm using Entity Framework 6 to populate the Item object and using chained includes to populate the PrimaryNode and User objects within it.

When the first chained Include has a null object then the whole object returns as null, for example:

using (var db = new MyContext())
{
    var item = db.Items.Include(i => i.User).Include(n => n.PrimaryNode).FirstOrDefault(i => i.ItemId == id);
}

If in the above example i.User is null then the item variable is null. Whats the best way of populating both the sub-objects in a way that if a sub-object is null then the parent object and the other sub-object will still be populated?

Answer 1

I think it would be better if you use Lazy loading int his situation. Just make the User and PrimaryNode virtual:

public class Item
{
   [Key]
   public int ItemId { get; set; }
   public string ItemName { get; set; }
   public virtual Node PrimaryNode { get; set; }
   public virtual User User { get; set; }
}

And then:

var db = new MyContext();
var item = db.Items.FirstOrDefault(i => i.ItemId == id);

Answer 2

I don't think your issue is due to the Include calls. According with the documentation :

This extension method calls the Include(String) method of the IQueryable source object, if such a method exists. If the source IQueryable does not have a matching method, then this method does nothing .

In other words is going to be translated to:

 var item = db.Items.Include("User").Include("PrimaryNode").FirstOrDefault(i => i.ItemId == id);

My question is, are you sure you have an Item with that id properly related with existing rows in Users and PrimaryNodes tables in your DB?. When you call Include method at the end is going to be translated to a join, so if the FK of your relationship doesn't match with the PK that reference, your query should not return what you are expecting.

Anyways, if you want to try another variant to load related properties you can use Explicit Loading :

var item = db.Items.FirstOrDefault(i => i.ItemId == id);
context.Entry(item).Reference(p => p.PrimaryNode).Load(); 
context.Entry(item).Reference(p => p.User).Load();

Answer 3

As others have mentioned, I think your issue is not due to the Includes. However, I think the following method has value. It is functionally equivalent to what you are already doing with the chained includes, but I think it has several benefits including making the intention of the code clear to the user.

The includes can be placed in Extension methods:

using System.Data.Entity;
using System.Linq;

namespace Stackoverflow
{
    public static class EntityExtensions
    {
        public static IQueryable<Item> IncludePrimaryNode(this IQueryable<Item> query)
        {
            // eager loading if this extension method is used
            return query.Include(item => item.PrimaryNode);
        }

        public static IQueryable<Item> IncludeUser(this IQueryable<Item> query)
        {
            // eager loading if this extension method is used
            return query.Include(item => item.User);
        }
    }
}

Then, you can use the extensions as follows:

using (var db = new MyContext())
{
    var itemQuery = db.Items.IncludeUser();

    itemQuery = itemQuery.IncludePrimaryNode();

    var item = itemQuery.FirstOrDefault(i => i.Id == 1);
}

It's just another way of doing the same thing, but I like the clarity it adds to the code.