EF Core如何映射含连接表与多引用表的多对多关系？

问题场景 #

现有不可修改的数据库架构如下：

MainTable
- Id
- ...

JoinTable
- MainTableId
- RefTableId（指向某一引用表的记录）
- RefTableName（指定关联的引用表）

RefTableA
- Id
- ...

RefTableB
- Id
- ...

该架构通过JoinTable的RefTableName字段，实现MainTable与任意引用表的多对多关联。此场景在EF Core中可实现，以下是具体解决方案：

解决方案 #

1. 定义实体类 #

创建对应数据库表的实体类，为引用表抽象基类以统一处理逻辑：

public class MainTable
{
    public int Id { get; set; }
    // 其他业务属性
    public ICollection<JoinTable> JoinRecords { get; set; } = new List<JoinTable>();
}

public class JoinTable
{
    public int MainTableId { get; set; }
    public int RefTableId { get; set; }
    public string RefTableName { get; set; }

    public MainTable MainTable { get; set; }
}

// 抽象基类，统一所有引用表的Id属性
public abstract class BaseRefTable
{
    public int Id { get; set; }
}

public class RefTableA : BaseRefTable
{
    // RefTableA专属属性
}

public class RefTableB : BaseRefTable
{
    // RefTableB专属属性
}

2. 配置DbContext #

在DbContext中配置实体映射，重点处理JoinTable的主键与外键关系：

public class AppDbContext : DbContext
{
    public DbSet<MainTable> MainTables { get; set; }
    public DbSet<JoinTable> JoinTables { get; set; }
    public DbSet<RefTableA> RefTableAs { get; set; }
    public DbSet<RefTableB> RefTableBs { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 配置JoinTable的复合主键（MainTableId + RefTableId + RefTableName）
        modelBuilder.Entity<JoinTable>()
            .HasKey(j => new { j.MainTableId, j.RefTableId, j.RefTableName });

        // 配置JoinTable到MainTable的外键关联
        modelBuilder.Entity<JoinTable>()
            .HasOne(j => j.MainTable)
            .WithMany(m => m.JoinRecords)
            .HasForeignKey(j => j.MainTableId);

        // 无需配置JoinTable到引用表的外键，因为关联关系由RefTableName动态指定，EF Core无法自动识别
    }
}

3. 实现关联查询 #

由于EF Core原生不支持这种动态多对多的导航属性，需手动编写关联查询，或封装为扩展方法简化复用：

基础查询示例

// 获取Id为1的MainTable关联的所有RefTableA记录
var mainTableId = 1;
var refTableARecords = await context.RefTableAs
    .Join(
        context.JoinTables.Where(j => j.MainTableId == mainTableId && j.RefTableName == nameof(RefTableA)),
        a => a.Id,
        j => j.RefTableId,
        (a, j) => a
    )
    .ToListAsync();

封装扩展方法

public static async Task<List<T>> GetRelatedRefRecordsAsync<T>(this AppDbContext context, int mainTableId) 
    where T : BaseRefTable
{
    var refTableName = typeof(T).Name;
    return await context.Set<T>()
        .Join(
            context.JoinTables.Where(j => j.MainTableId == mainTableId && j.RefTableName == refTableName),
            r => r.Id,
            j => j.RefTableId,
            (r, j) => r
        )
        .ToListAsync();
}

// 使用方式
var refTableARecords = await context.GetRelatedRefRecordsAsync<RefTableA>(1);
var refTableBRecords = await context.GetRelatedRefRecordsAsync<RefTableB>(1);

补充说明 #

此前尝试的TPC配置、鉴别器方案不适用该场景：

• TPC是表继承的映射策略，用于将继承结构映射到多张表，与当前动态关联不同表的多对多场景无关；
• 鉴别器用于单表继承（TPH）场景，通过字段区分不同子类，同样不匹配当前架构的动态关联逻辑。

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