EF.Core一对一关联查询失效，关联对象始终为null求助

Hey there, let's fix that one-to-one relationship issue in EF Core you're dealing with! The problem here is that EF Core isn't automatically loading the IncomingData related to your History records by default—let's break down the solutions step by step.

First: Fix the Query with Eager Loading #

The quickest way to get your IncomingData property populated is to use eager loading with the Include() method. This tells EF Core to fetch the related data in a single query instead of leaving it null.

Your original query:

var histories = _db.Histories.Where(x => x.IMEI == device.IMEI).OrderByDescending(x => x.Timestamp);

Update it to include the related IncomingData:

var histories = _db.Histories
    .Include(x => x.IncomingData) // This line ensures related data is loaded
    .Where(x => x.IMEI == device.IMEI)
    .OrderByDescending(x => x.Timestamp)
    .ToList(); // Execute the query immediately (avoids unexpected behavior with deferred execution)

After this change, each History in your histories collection will have its IncomingData property populated correctly, no more nulls!

Second: Ensure Your One-to-One Relationship is Properly Configured #

While eager loading fixes the query issue, it's good to make sure EF Core fully understands your relationship. For one-to-one relationships, EF Core needs clear guidance on which entity is the dependent (the one with the foreign key, which is History here since it has IncomingDataId) and which is the principal (IncomingData).

Add this configuration to your DbContext's OnModelCreating method using Fluent API:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<History>()
        .HasOne(h => h.IncomingData) // Each History has one IncomingData
        .WithOne(id => id.History) // Each IncomingData has one History
        .HasForeignKey<History>(h => h.IncomingDataId); // Specify the foreign key on History
}

This removes any ambiguity for EF Core and ensures the relationship is mapped correctly behind the scenes.

Why Your Original Loop Approach is a Bad Idea #

That foreach loop you're using right now causes what's called an N+1 query problem: you run 1 query to get all History records, then run an additional query for each History to fetch its IncomingData. This gets really slow as your dataset grows—definitely replace it with the eager loading approach above.

Bonus: Lazy Loading (Optional) #

If you prefer EF Core to automatically load related data when you access the navigation property, you can enable lazy loading. But note that this can still lead to N+1 issues if you're not careful. To set it up:

1. Install the Microsoft.EntityFrameworkCore.Proxies NuGet package.
2. Update your DbContext configuration to enable proxies:

   protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
   {
       optionsBuilder.UseLazyLoadingProxies()
           .UseSqlServer("your_connection_string_here");
   }
   

3. Mark your navigation properties as virtual:

   public class IncomingData 
   { 
       [Key] [Required] public int Id { get; set; } 
       // ... other properties
       public virtual History History { get; set; } 
   }
   
   public class History 
   { 
       [Key] public int Id { get; set; } 
       // ... other properties
       [ForeignKey("IncomingDataId")] 
       public virtual IncomingData IncomingData { get; set; } 
   }
   

Again, eager loading is usually the better choice for performance and predictability.

内容的提问来源于stack exchange，提问作者Ludisposed