.NET Core类WordPress插件式共享数据库Code First最佳实践咨询

这个场景太常见了——就像你说的，类似WordPress的插件式模块，每个模块管好自己的表，但又得依赖系统核心的公共表（比如用户表）。我之前做过类似的模块化系统，踩过不少EF Core迁移冲突的坑，下面分享几个经过实践验证的最佳方案，你可以根据自己的需求选：

1. 共享核心DbContext，用实体配置类隔离模块 #

这是我最推荐的方案，适合模块是系统内部组件、不需要独立分发的场景。核心思路是：把公共表（比如Identity的AspNetUsers）放在一个核心DbContext里，每个模块只负责定义自己的实体和配置，通过IEntityTypeConfiguration<T>接口把实体映射到数据库表，最后统一由核心DbContext加载所有配置并管理迁移。

具体操作： #

• 先创建一个CoreDbContext，继承IdentityDbContext<ApplicationUser>，负责公共表的基础配置：

public class CoreDbContext : IdentityDbContext<ApplicationUser>
{
    public CoreDbContext(DbContextOptions<CoreDbContext> options) : base(options) { }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // 加载核心程序集的配置类
        modelBuilder.ApplyConfigurationsFromAssembly(typeof(CoreDbContext).Assembly);
        // 加载项目A的配置类（如果在不同程序集）
        modelBuilder.ApplyConfigurationsFromAssembly(typeof(CompanyConfiguration).Assembly);
        // 加载FunnyNames项目的配置类
        modelBuilder.ApplyConfigurationsFromAssembly(typeof(FunGeneratedNameConfiguration).Assembly);
    }
}

• 项目A里定义Company、Car实体，然后写对应的配置类：

public class CompanyConfiguration : IEntityTypeConfiguration<Company>
{
    public void Configure(EntityTypeBuilder<Company> builder)
    {
        builder.ToTable("companies");
        // 其他配置：主键、索引、关系等
    }
}

public class CarConfiguration : IEntityTypeConfiguration<Car>
{
    public void Configure(EntityTypeBuilder<Car> builder)
    {
        builder.ToTable("cars");
        // 配置和用户的关联
        builder.HasOne(c => c.Owner).WithMany(u => u.Cars).HasForeignKey(c => c.OwnerId);
    }
}

• FunnyNames项目里定义FunGeneratedName实体，配置类里关联User和Car：

public class FunGeneratedName
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int CarId { get; set; }
    public Car RelatedCar { get; set; }
    public string CreatedById { get; set; }
    public ApplicationUser CreatedBy { get; set; }
}

public class FunGeneratedNameConfiguration : IEntityTypeConfiguration<FunGeneratedName>
{
    public void Configure(EntityTypeBuilder<FunGeneratedName> builder)
    {
        builder.ToTable("fun_generatedNames");
        // 配置外键关联
        builder.HasOne(f => f.RelatedCar).WithMany().HasForeignKey(f => f.CarId);
        builder.HasOne(f => f.CreatedBy).WithMany().HasForeignKey(f => f.CreatedById);
    }
}

优点： #

• 所有表的迁移由核心DbContext统一管理，完全避免表重复创建的冲突。
• 模块之间的边界清晰，只负责自己的实体和配置，依赖公共表直接通过导航属性访问即可。

2. 模块DbContext继承核心DbContext，拆分迁移管理 #

如果你的模块必须保留独立的DbContext（比如模块有自己的业务逻辑边界），可以让模块DbContext继承核心DbContext，同时控制迁移只针对模块自己的表。

具体操作： #

• 先创建CoreDbContext，负责公共表（AspNetUsers等）的迁移：

public class CoreDbContext : IdentityDbContext<ApplicationUser>
{
    public CoreDbContext(DbContextOptions<CoreDbContext> options) : base(options) { }
}

• 项目A的ADbContext继承CoreDbContext，添加自己的DbSet，并排除公共表的迁移：

public class ADbContext : CoreDbContext
{
    public DbSet<Company> Companies { get; set; }
    public DbSet<Car> Cars { get; set; }

    public ADbContext(DbContextOptions<ADbContext> options) : base(options) { }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        // 标记公共表不参与当前DbContext的迁移
        modelBuilder.Entity<ApplicationUser>().Metadata.SetIsTableExcludedFromMigrations(true);
    }
}

• FunnyNames项目的FunnyNamesDbContext同理：

public class FunnyNamesDbContext : CoreDbContext
{
    public DbSet<FunGeneratedName> FunGeneratedNames { get; set; }

    public FunnyNamesDbContext(DbContextOptions<FunnyNamesDbContext> options) : base(options) { }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        // 排除公共表的迁移
        modelBuilder.Entity<ApplicationUser>().Metadata.SetIsTableExcludedFromMigrations(true);
        modelBuilder.Entity<Car>().Metadata.SetIsTableExcludedFromMigrations(true);
        
        // 配置自己的实体
        modelBuilder.Entity<FunGeneratedName>().ToTable("fun_generatedNames");
        // 关联Car和User
        modelBuilder.Entity<FunGeneratedName>()
            .HasOne(f => f.RelatedCar)
            .WithMany()
            .HasForeignKey(f => f.CarId);
    }
}

迁移命令： #

• 先运行核心DbContext的迁移创建公共表：

dotnet ef migrations add InitialCore --context CoreDbContext
dotnet ef database update --context CoreDbContext

• 再分别运行模块DbContext的迁移：

# 项目A的迁移
dotnet ef migrations add AddCompaniesCars --context ADbContext
dotnet ef database update --context ADbContext

# FunnyNames的迁移
dotnet ef migrations add AddFunGeneratedNames --context FunnyNamesDbContext
dotnet ef database update --context FunnyNamesDbContext

优点： #

• 模块保留独立的DbContext，业务逻辑边界清晰。
• 迁移拆分管理，不会出现公共表重复创建的冲突。

3. 完全独立的模块DbContext（适合NuGet包分发） #

如果你的模块要做成独立的NuGet包，不想依赖系统的核心DbContext，那可以让模块DbContext只定义自己的表，对依赖的公共表只做映射但不生成迁移。

具体操作： #

• 模块里定义依赖的公共实体（只包含需要的字段）：

// 模块里的User实体（只保留需要的字段）
public class User
{
    public string Id { get; set; }
    public string Email { get; set; }
}

public class Car
{
    public int Id { get; set; }
    public string Model { get; set; }
}

• 在模块的DbContext里映射这些实体到已有的公共表，并标记它们不参与迁移：

public class FunnyNamesDbContext : DbContext
{
    public DbSet<FunGeneratedName> FunGeneratedNames { get; set; }
    // 声明依赖的公共实体
    public DbSet<User> Users { get; set; }
    public DbSet<Car> Cars { get; set; }

    public FunnyNamesDbContext(DbContextOptions<FunnyNamesDbContext> options) : base(options) { }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 配置自己的表
        modelBuilder.Entity<FunGeneratedName>().ToTable("fun_generatedNames");
        // 关联User和Car
        modelBuilder.Entity<FunGeneratedName>()
            .HasOne(f => f.CreatedBy)
            .WithMany()
            .HasForeignKey(f => f.CreatedById);
        modelBuilder.Entity<FunGeneratedName>()
            .HasOne(f => f.RelatedCar)
            .WithMany()
            .HasForeignKey(f => f.CarId);

        // 映射公共表，并排除迁移
        modelBuilder.Entity<User>()
            .ToTable("AspNetUsers")
            .HasKey(u => u.Id)
            .Metadata.SetIsTableExcludedFromMigrations(true);
        
        modelBuilder.Entity<Car>()
            .ToTable("cars")
            .HasKey(c => c.Id)
            .Metadata.SetIsTableExcludedFromMigrations(true);
    }
}

注意点： #

• 必须确保系统核心已经创建好公共表（AspNetUsers、cars），再运行模块的迁移。
• 模块里的公共实体字段要和数据库表的字段一致，否则会出现映射错误。

优点： #

• 模块完全独立，作为NuGet包分发时不需要依赖系统核心的DbContext或实体。

4. 只读依赖公共表（适合只需要读取的场景） #

如果FunnyNames项目只需要读取User或Car表的数据，不需要修改，那可以把这些表映射成数据库视图，EF Core会把它们当成只读对象，不会尝试创建表。

代码示例： #

public class FunnyNamesDbContext : DbContext
{
    public DbSet<FunGeneratedName> FunGeneratedNames { get; set; }
    // 映射成视图（直接指向已有的表）
    public DbSet<User> Users { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>().ToView("AspNetUsers");
        modelBuilder.Entity<FunGeneratedName>().ToTable("fun_generatedNames");
        // 关联配置...
    }
}

优点： #

• 最简单的只读场景解决方案，完全避免迁移冲突。

总结一下怎么选： #

• 内部模块、统一管理：选方案1，最省心。
• 需要独立DbContext但耦合核心：选方案2。
• 独立NuGet包分发：选方案3。
• 只读依赖公共表：选方案4。

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