Entity Framework Core：多对象与Note对象的一对多映射方案咨询

针对你这种Note需要关联多个实体（Contact、Quote等，且每个实体可拥有多个Note）的场景，我整理了几种最佳实践方案，你可以根据自己的实际需求来选择：

方案一：表继承（TPH，Table Per Hierarchy）—— 适合Note仅归属一种实体的场景 #

如果你的业务规则是一个Note只能属于Contact或Quote中的某一个，不能同时关联多个，那么表继承是最干净、扩展性最好的方案。它通过在数据库中用一张表存储所有Note类型，用Discriminator列区分归属，代码层面用抽象基类+子类实现：

代码实现 #

首先定义抽象基类Note：

public abstract class Note
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string NoteDetails { get; set; }
    public DateTime CreatedDate { get; set; }
}

然后为每个关联实体创建对应的Note子类：

// 关联Contact的Note
public class ContactNote : Note
{
    public int ContactId { get; set; }
    public Contact NoteContact { get; set; }
}

// 关联Quote的Note
public class QuoteNote : Note
{
    public int QuoteId { get; set; }
    public Quote NoteQuote { get; set; }
}

修改Contact和Quote类，让它们关联对应的Note子类：

public class Contact
{
    public int Id { get; set; }
    // 其他Contact属性...
    public ICollection<ContactNote> Notes { get; set; } = new List<ContactNote>();
}

public class Quote
{
    public int Id { get; set; }
    // 其他Quote属性...
    public ICollection<QuoteNote> Notes { get; set; } = new List<QuoteNote>();
}

最后在EF Core的OnModelCreating中配置继承规则：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Note>()
        .HasDiscriminator<string>("NoteType") // 区分Note类型的列
        .HasValue<ContactNote>("Contact")
        .HasValue<QuoteNote>("Quote");
}

优点 #

• 数据完整性强：每个Note只能归属一种实体，不会出现同时关联多个实体的无效数据
• 扩展性好：后续要加新实体（比如Order），只需要新增OrderNote子类并配置Discriminator即可
• 导航属性清晰：Contact直接关联ContactNote，不会和Quote的Note混淆

方案二：多对多关联表—— 适合Note可同时关联多个实体的场景 #

如果你的业务允许一个Note同时属于多个不同类型的实体（比如一个Note既和某个Contact相关，又和某个Quote相关），那么用中间关联表的多对多方案是最佳选择。

代码实现 #

首先定义独立的Note类：

public class Note
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string NoteDetails { get; set; }
    public DateTime CreatedDate { get; set; }

    // 关联中间表的集合
    public ICollection<ContactNote> ContactNotes { get; set; } = new List<ContactNote>();
    public ICollection<QuoteNote> QuoteNotes { get; set; } = new List<QuoteNote>();
}

创建中间关联表实体：

// Contact和Note的关联表
public class ContactNote
{
    public int ContactId { get; set; }
    public Contact Contact { get; set; }
    public int NoteId { get; set; }
    public Note Note { get; set; }
}

// Quote和Note的关联表
public class QuoteNote
{
    public int QuoteId { get; set; }
    public Quote Quote { get; set; }
    public int NoteId { get; set; }
    public Note Note { get; set; }
}

修改Contact和Quote类，添加关联集合（可以加便捷属性快速获取关联的Note）：

public class Contact
{
    public int Id { get; set; }
    // 其他Contact属性...
    public ICollection<ContactNote> ContactNotes { get; set; } = new List<ContactNote>();
    
    // 便捷属性：直接获取关联的所有Note
    public IEnumerable<Note> Notes => ContactNotes.Select(cn => cn.Note);
}

public class Quote
{
    public int Id { get; set; }
    // 其他Quote属性...
    public ICollection<QuoteNote> QuoteNotes { get; set; } = new List<QuoteNote>();
    
    // 便捷属性：直接获取关联的所有Note
    public IEnumerable<Note> Notes => QuoteNotes.Select(qn => qn.Note);
}

在EF Core中配置中间表的主键和关联关系：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 配置ContactNote的复合主键
    modelBuilder.Entity<ContactNote>()
        .HasKey(cn => new { cn.ContactId, cn.NoteId });
    
    // 配置Contact和ContactNote的关联
    modelBuilder.Entity<ContactNote>()
        .HasOne(cn => cn.Contact)
        .WithMany(c => c.ContactNotes)
        .HasForeignKey(cn => cn.ContactId);
    
    // 配置Note和ContactNote的关联
    modelBuilder.Entity<ContactNote>()
        .HasOne(cn => cn.Note)
        .WithMany(n => n.ContactNotes)
        .HasForeignKey(cn => cn.NoteId);

    // 同理配置QuoteNote
    modelBuilder.Entity<QuoteNote>()
        .HasKey(qn => new { qn.QuoteId, qn.NoteId });
    
    modelBuilder.Entity<QuoteNote>()
        .HasOne(qn => qn.Quote)
        .WithMany(q => q.QuoteNotes)
        .HasForeignKey(qn => qn.QuoteId);
    
    modelBuilder.Entity<QuoteNote>()
        .HasOne(qn => qn.Note)
        .WithMany(n => n.QuoteNotes)
        .HasForeignKey(qn => qn.NoteId);
}

优点 #

• 灵活性极高：一个Note可以被多个不同类型的实体共享
• 数据结构清晰：Note是独立的实体，关联关系通过中间表维护
• 扩展性好：新增实体时只需要新增对应的中间表和关联配置

方案三：改进现有方案—— 适合快速临时解决，不推荐长期使用 #

如果你不想大幅修改现有代码，可以通过添加约束来解决现有方案的缺陷（比如同时设置ContactId和QuoteId的无效数据）：

代码实现 #

首先在Note类中添加验证逻辑：

public class Note
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string NoteDetails { get; set; }
    public DateTime CreatedDate { get; set; }
    public int? ContactId { get; set; }
    public int? QuoteId { get; set; }
    public Contact NoteContact { get; set; }
    public Quote NoteQuote { get; set; }

    // 验证：确保只有一个外键非空
    public bool IsValid()
    {
        return (ContactId.HasValue != QuoteId.HasValue);
    }
}

然后在EF Core中配置数据库级别的检查约束（EF Core 3.0+支持）：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Note>()
        .HasCheckConstraint("CK_Note_OnlyOneOwner", 
            "(ContactId IS NOT NULL AND QuoteId IS NULL) OR (ContactId IS NULL AND QuoteId IS NOT NULL)");
}

缺点 #

• 扩展性极差：后续新增实体（比如Order）需要添加新的可空外键、修改检查约束和验证逻辑
• 代码冗余：随着实体增多，Note类会越来越臃肿
• 容易出现维护问题：长期来看，这种“万能Note”会导致数据结构混乱

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