一对一关系未加载所有实体

Question

I have a (contrived and over-simplified, due to contractual constraints) data model that should look like this:

public class ProvisionalData
{
    public int ProvisionalDataID { get; set; }
    public string Data { get; set; }

    public Lot Lot { get; set; }
}

public class Destination 
{
    public int DestinationID { get; set; }
    public string Name { get; set; }
}

public class LotDestination
{
    public int LotDestinationID { get; set; }
    public int DestinationID { get; set; }
    public DateTime Month { get; set; }

    public Destination Destination { get; set; }
}

public class Lot
{
    public int LotID { get; set; }
    public int ProvisionalDataID { get; set; }
    public int LotDestinationID { get; set; }


    public ProvisionalData ProvisionalData { get; set; }
    public LotDestination LotDestination { get; set; }
}

The relationship from Lot to ProvisionalData is a required one-to-one on both sides. Please note, this is not the whole model, nor is the domain the concern. The concern is with configuring the one-to-one relationship.

My relevant to the one-to-one mapping fluent configurations:

public class LotConfig : EntityTypeConfiguration<Lot>
{
    public LotConfig()
    {
        ToTable("Lot");
        HasKey(x => x.LotID);

        HasRequired(x => x.ProvisionalData)
            .WithRequiredDependent(x => x.Lot)
            .WillCascadeOnDelete(true);
    }
}


public class ProvisionalDataConfig : EntityTypeConfiguration<ProvisionalData>
{
    public ProvisionalDataConfig()
    {
        ToTable("ProvisionalData");
        HasKey(x => x.ProvisionalDataID);
    }
}

The other relationships shown are in fact set up - I have verified that they are being configured in my context, and all IDbSets exist and function correctly. In fact, everything "works" with this setup, except that some ProvisionalData entities on navigation properties are not populated by the following query:

var lotDestination = db.lotDestinations
    .Where(x => x.DestinationId == destinationId && x.Month == month)
    .Include(x => x.Lots)
    .Include("Lots.ProvisionalData")
    .Include(x => x.Destination)
    .SingleOrDefault();    

In my real dataset, this query will return a destination with 30 Lots. 16 of those lots have their ProvisionalData navigation property loaded. 14 do not. This problem persists when I manually loop through each Lot and db.Entry(lot).Reference(ProvisionalData).Load() . When I examine those entries, all 30 return true for .IsLoaded . The query and .Includes appears to be doing what they are supposed to, but some of the entities aren't coming back for reasons I don't understand. I'm hoping it's something simple that I can't see because I've been staring at it for too long.

However, when I change the relationship (ignoring existing database constraints) to a one-to-many with ProvisionalData entities looking like this:

public class ProvisionalData
{
public int ProvisionalDataID { get; set; }
public string Data { get; set; }

public IList<Lot> Lots { get; set; }
}

and a new Lot configuration like this:

public class LotConfig : EntityTypeConfiguration<Lot>
{
    public LotConfig()
    {
        ToTable("Lot");
        HasKey(x => x.LotID);

        HasRequired(x => x.ProvisionalData)
            .WithMany(x => x.Lots)
            .HasForeignKey(x => x.ProvisionalDataID);
    }
}

everything works flawlessly. The only drawback here is that this doesn't reflect the true constraints in the database, so you could technically try to add multiple Lots to the same piece of ProvisionalData, which would break when trying to save. I can build the logic in to prevent this myself, but why can't I express it here in Entity Framework? Is my configuration incorrect?

Also interestingly, when I switch the above-mentioned query around to this dumb version to test things (with the one-to-one mapping still in place in EF):

var quota = db.Lots
    .Where(l => l.LotDestination.DestinationID == destinationId && l.LotDestination.Month == m)
    .Include(x => x.ProvisionalData)
    .Include(x => x.LotDestination)
    .Include(x => x.LotDestination.Destination)
    .Select(x => x.LotDestination)
    .FirstOrDefault();

all of the provisional data comes back, but some of the Destinations do not . This hints to me that it has something to do with including navigation properties multiple levels deep across a one-to-one. Has anyone else experienced this behavior before?

Answer 1

EF does not officially support 1:1 associations other than in shared primary key 1:1 association situations.

What you are doing is create 1:many's and trying to tell EF that it's really a 1:1. The problem is, the db schema is really a 1:many schema and EF will have problems here.

If your requirement is 1:1, then you need to use a shared primary key (both entities have the same primary key), and one also treats it as a foreign key).

Answer 2

I am facing the problems before, Mine solution was using 1:many because if POCOA include POCOB

.Include(x => x.POCOA.POCOB) 

really return the POCOB as a list, since we know it 100% return one record, then during getting the data, we can say a.SingleOrDefault();