实体框架5急切加载父属性

Question

I have a query on some parent entity ( Order ) and I want to load some of its sub collections or properties eagerly. I have a query like this:

public void QueryMethod()
{
    using (var context = new MyContext())
    {
        var orders = context.Order.Include("OrderProduct")
                                  .Include("OrderProduct.ProductVariant")
                                  .Where(some query)
                                  .ToList();
    }
}

What I am doing is I loop through this order collection and for each Order I reach to OrderProduct and ProductVariant properties. I can do this inside the query method, when the context is alive. But when I try to access ProductVariant.OrderProduct outside the context, I get ObjectDisposedException .

By the way, I am trying to access to ProductVariant.OrderProduct for some weird reason. I think I shouldn't access it like this but my point is that I can reach from OrderProduct to ProductVariant , but I can't access from ProductVariant to OrderProduct . I am wondering why I get this error despite that I added OrderProduct.ProductVariant into my eager loading properties. Isn't it supposed to work both ways?

Any help will be very much appreciated.

Answer 1

The fact that you get an ObjectDisposedException outside the context indicates that Entity Framework tries to load the object that ProductVariant.OrderProduct is refering to via lazy loading from the database.

Now, this doesn't necessarily mean - and this statement sounds odd - that ProductVariant.OrderProduct isn't already loaded and filled with the correct entity. Probably it is, because it's just the inverse property of OrderProduct.ProductVariant which you have loaded via eager loading. For one-to-one and one-to-many relationships EF will populate the inverse navigation properties automatically when a navigation property is loaded ("Relationship fixup").

Despite the inverse navigation property is populated it isn't necessarily marked as loaded which is a flag maintained by the context per navigation property that tells EF if a navigation property has to be loaded from the database via lazy loading when you access it in your code.

For a one-to-many relationship for example it is easily seen that EF must not mark a navigation property as loaded when it gets populated due to relationship fixup. For instance: If you load an order including its customer reference - context.Orders.Include("Customer").Single... - the Orders collection in the eagerly loaded customer would contain this loaded order (because of relationship fixup). But this single order is most likely not the only order that this customer has (or at least EF cannot know if that's the only order or if there are more in the database). If you access the Customer.Orders collection you usually expect that not only this single order is returned but all orders of the customer - in other words, you expect that a lazy loading query happens that loads the rest of the customer's orders from the database.

Now, this argument isn't really convincing for a one-to-one relationship because for such a relationship it is clear that there can't be more than one related object in the database. So, why would EF want to run a lazy loading query if this single related object is already loaded?

I don't know why EF still tries to load the inverse navigation property for the one-to-one relationship, but possiby it just doesn't distinguish between a one-to-many and a one-to-one relationship in this respect. Maybe EF follows the general rule that if the principal side of the relationship is populated by relationship fixup it isn't marked as loaded and lazy loading will happen in any case when you access it. (I can't really see from your code snippet if OrderProduct or ProductVariant is the principal, it is just a guess.)

Anyway, in your situation I would disable lazy loading or even proxy creation (which includes disabling lazy loading) because you're using Include inside a using block and lazy loading has no benefit here. The exception you are having should disappear then:

using (var context = new MyContext())
{
    context.Configuration.ProxyCreationEnabled = false;

    var orders = context.Order.Include("OrderProduct")
                              .Include("OrderProduct.ProductVariant")
                              .Where(some query)
                              .ToList();
}