如何在EF Core中建模多外键关联的Person与Family关系

针对RootsMagic数据库的Person与Family关联场景，无需修改第三方数据库的前提下，有几种更优的方式实现可查询的Families关联：

方案1：显式双导航属性+内存合并（兼容Include） #

先在Person模型中声明两个对应父亲、母亲身份的公开导航属性，再通过未映射属性合并结果。查询时同时Include两个导航属性，就能直接访问合并后的Families集合：

模型定义 #

public class Person
{
    public int PersonID { get; set; }
    // 其他人员属性（如姓名、出生日期等）

    // 作为父亲的家庭集合
    public ICollection<Family> FatherOfFamilies { get; set; } = new List<Family>();
    // 作为母亲的家庭集合
    public ICollection<Family> MotherOfFamilies { get; set; } = new List<Family>();

    // 未映射的合并属性，返回所有作为父母的家庭
    [NotMapped]
    public IEnumerable<Family> Families => FatherOfFamilies.Concat(MotherOfFamilies);
}

public class Family
{
    public int FamilyID { get; set; }
    public int? FatherID { get; set; }
    public int? MotherID { get; set; }
    // 其他家庭属性

    public Person Father { get; set; }
    public Person Mother { get; set; }
}

上下文配置 #

在DbContext的OnModelCreating中配置两个外键关联：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 配置家庭与父亲的关联
    modelBuilder.Entity<Family>()
        .HasOne(f => f.Father)
        .WithMany(p => p.FatherOfFamilies)
        .HasForeignKey(f => f.FatherID)
        .OnDelete(DeleteBehavior.Restrict); // 避免级联删除冲突

    // 配置家庭与母亲的关联
    modelBuilder.Entity<Family>()
        .HasOne(f => f.Mother)
        .WithMany(p => p.MotherOfFamilies)
        .HasForeignKey(f => f.MotherID)
        .OnDelete(DeleteBehavior.Restrict);
}

查询方式 #

虽然不能直接Include(p => p.Families)，但可以同时Include两个导航属性，之后直接访问Families：

var person = context.Persons
    .Include(p => p.FatherOfFamilies)
    .Include(p => p.MotherOfFamilies)
    .FirstOrDefault(p => p.PersonID == targetId);

// 直接获取所有作为父母的家庭
var allParentFamilies = person.Families;

优点：模型结构清晰，符合EF导航属性设计规范，查询逻辑直观；缺点：需要同时Include两个属性，无法通过单个Include完成。

方案2：数据库层面投影查询（性能更优） #

通过LINQ投影直接在数据库中合并家庭数据，避免内存中拼接，同时可以封装为复用方法：

自定义查询方法（DbContext中） #

public IQueryable<PersonWithFamilies> GetPersonsWithAllFamilies()
{
    return Persons.Select(p => new PersonWithFamilies
    {
        PersonID = p.PersonID,
        Name = p.Name, // 复制需要的人员属性
        // 直接查询该人员作为父母的所有家庭
        Families = Families.Where(f => f.FatherID == p.PersonID || f.MotherID == p.PersonID).ToList()
    });
}

// 定义DTO存储带家庭的人员信息
public class PersonWithFamilies
{
    public int PersonID { get; set; }
    public string Name { get; set; }
    // 其他需要的属性
    public ICollection<Family> Families { get; set; } = new List<Family>();
}

查询调用 #

var person = context.GetPersonsWithAllFamilies()
    .FirstOrDefault(p => p.PersonID == targetId);

优点：数据库层面完成过滤合并，性能更好；可以直接获取包含所有家庭的结果，无需额外操作；缺点：需要定义DTO，无法直接使用原Person模型。

方案3：封装扩展方法简化查询 #

如果不想定义DTO，可以封装一个扩展方法，简化同时Include两个导航属性的操作：

public static IQueryable<Person> IncludeFamilies(this IQueryable<Person> query)
{
    return query.Include(p => p.FatherOfFamilies)
                .Include(p => p.MotherOfFamilies);
}

查询调用 #

var person = context.Persons
    .IncludeFamilies()
    .FirstOrDefault(p => p.PersonID == targetId);

var allFamilies = person.Families;

优点：复用性强，查询时只需调用IncludeFamilies()即可，代码更简洁；缺点：本质还是方案1的封装，合并逻辑仍在内存中。

方案4：直接查询家庭集合（最灵活） #

如果只需要获取某个人的家庭，也可以直接查询Family表，通过FatherID或MotherID过滤：

var families = context.Families
    .Where(f => f.FatherID == targetId || f.MotherID == targetId)
    .ToList();

优点：无需修改Person模型，查询逻辑最简单；缺点：无法直接通过Person实体导航到家庭，适合单独查询家庭的场景。

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