实体框架联接说明

Question

I have the following entities

//Active Auction Entity
public class ActiveAuction
{
    public int Id { get; set; }

    public string Title { get; set; }

    public int? FirstAuctionId { get; set; }

    public int? SecondAuctionId { get; set; }

    public int? ThirdAuctionId { get; set; }

    public virtual Auction FirstAuction { get; set; }

    public virtual Auction SecondAuction { get; set; }

    public virtual Auction ThirdAuction { get; set; }
}

---

// Auction Entity
public class Auction
{
    public int AuctionId { get; set; }

    public AuctionStatus AuctionStatus { get; set; }

    public int? DepartmentId { get; set; }

    public virtual Department Department { get; set; }

}

---

// Department Entity
public class Department
{
    public int DepartmentId { get; set; }

    public string DepartmentName { get; set; }

    public int? AdminId { get; set; }

    public virtual Admin Admin { get; set; }
}

---

What I'm trying to do is to get Active Auctions with Auctions loaded and Auction also have Departments loaded I know that I should write Include for every object to be loaded so the generated SQL by EF will have join statement to select there object for me

but this is the existing code

 using (var dc = DataContext())
    {
        await dc.Auction
           .Include("Department.Admin")
           .Where(i => i.Id == id && i.AuctionStatus == AuctionStatus.Accepted).ToListAsync();

        return await dc.ActiveAuction.
           SingleOrDefaultAsync(i => i.Id == id);
    }

I don't know How but this code works and the returned ActiveAuctions include all desired objects

I checked for SQL executed against the database and as expected it generate to separate queries.

I want an explanation to understand how the returned ActiveAcutions loaded with the other mentioned entities!!?

Answer 1

The reason is simple. As you most likely know, Entity Framework tracks entities you fetched from database, mostly to detect changes to them and apply those changes to database when you call SaveChanges . However, that means EF context has kind of cache of entities fetched from database so far.

EDIT : As correctly pointed in comments by @GertArnold - my explanation with dynamic proxies was completely wrong - it works this way even if ProxyCreationEnabled is false . The real reason is relationship fix up which is performed by entity framework when DetectChanges is called (it is called implicitly on various events, like attaching entity to context, or executing query over DbSet ). During that relationship fix up, EF synchronizes navigation properties and foreign keys which in your case causes behavior you observe. More about relationship fix up in MSDN

To verify this you may use this simple code:

using (var ctx = new TestEntities()) {
     ctx.Configuration.LazyLoadingEnabled = false;                
     ctx.Configuration.ProxyCreationEnabled = false;                
     var code = ctx.Codes.First();                
     var error = ctx.Errors.First();
     Debug.Assert(Object.ReferenceEquals(error.Code, code));                                
}

Here I first fetch some entity (Code), then I fetch another entity (Error) which has navigation property Code. You see that lazy loading is disabled . The following assert will pass, because error.Code and code is the same .NET object, which confirms it was fetched from context cache.

Answer 2

The behavior you are seeing is because EF internally maintains object cache per each DB context instance. Every time when query is executed, EF first checks internal cache to see if it contains neccessary entity. If entity is found, then it is returned from cache without even querying database.

In your sample here it what happens:

• First query gets some Auction entities and add them to cache;
• Second query gets filtered ActiveAuction entities and add them to cache;
• When you inspect results of second query you see that properties are already filled because they were found in cache by key;

You can change this behavior by changing MergeOption setting on database context instance. This setting changes how EF merges results from database to cache.

Possible values are as follows:

AppendOnly (default value)

Objects that do not exist in the object context are attached to the context. If an object is already in the context, the current and original values of object's properties in the entry are not overwritten with data source values. The state of the object's entry and state of properties of the object in the entry do not change. AppendOnly is the default merge option.

NoTracking

Objects are maintained in a Detached state and are not tracked in the ObjectStateManager. However, Entity Framework-generated entities and POCO entities with proxies maintain a reference to the object context to facilitate loading of related objects.

OverwriteChanges

Objects that do not exist in the object context are attached to the context. If an object is already in the context, the current and original values of object's properties in the entry are overwritten with data source values. The state of the object's entry is set to Unchanged, no properties are marked as modified.

PreserveChanges

Objects that do not exist in the object context are attached to the context.

( https://msdn.microsoft.com/en-us/library/system.data.objects.mergeoption(v=vs.110).aspx )

And here is a good article that describes all the options in more details and contains some code samples as well.

http://www.develop1.net/public/post/Do-you-understand-MergeOptions.aspx

EDIT: Just wanted to add that default behavior can lead to strange results if the first query does projection of entity (for example, selects only some columns). In this case entity will still be added to the cache even if it is only half loaded. This means that second query will return half loaded entity as well.

Answer 3

You can't use .Include("Department.Admin") since EF don't load inner inclusions like yours, say, Admin .

Note that , when you work with EF code first, It's better to determine the real relationships among tables, whether in classes or using fluent API, to meet a good design without anomaly. So, using three Auction s in ActiveAuction without any clarification may disturb you.

Another thing is that, It seems you're using ActiveAuction as foreign key in each Auction without any declaration! So change your Auction class to this:

public class Auction
{
    [ForeignKey("ActiveOne")]
    public int AuctionId { get; set; }

    public AuctionStatus AuctionStatus { get; set; }

    public int? DepartmentId { get; set; }

    public virtual Department Department { get; set; }

    [Required]
    public virtual ActiveAuction ActiveOne { get; set; } //match this name

}

With this in mind, I believe that there are some ambiguities in your models. Let's speak about the query. As you said :

What I'm trying to do is to get ActiveAuctions with Auctions loaded and Auction also have Departments loaded

So you can use something like this query:

await context.Auctions.Include("Department").Include("ActiveOne")
.Where(i => i.id == id && i.AuctionStatus == AuctionStatus.Accepted)
.Select(i => i.ActiveOne).ToListAsync();

Answer 4

当EF加载任何实体时，它将它们与缓存中的现有实体联系起来，从而使模型完整，指向所有已加载对象的所有引用。

Answer 5

"Lazy loading is the process whereby an entity or collection of entities is automatically loaded from the database the first time that a property referring to the entity/entities is accessed." See this article: https://msdn.microsoft.com/en-us/data/jj574232.aspx