单体架构中通用DbContext与AspNet Identity的架构冲突解决方案咨询

核心思路：用泛型抽象+依赖倒置打破循环依赖 #

Common作为基础公共层，只负责提供通用的DbContext框架，不绑定具体业务实体；把具体的用户类（ApplicationUser、UserA、UserB）和DbContext实现放在业务/数据层，让业务层依赖Common，而非反过来。

步骤1：在Common项目中定义泛型通用DbContext #

创建泛型基类，封装通用的DbContext逻辑（比如审计、事务、通用SaveChanges等），同时继承IdentityDbContext，约束泛型参数为IdentityUser的子类：

using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace YourProject.Common.Data
{
    // 这里用Guid作为主键，可替换为你实际使用的主键类型
    public abstract class BaseIdentityDbContext<TUser> : IdentityDbContext<TUser> 
        where TUser : IdentityUser<Guid>
    {
        protected BaseIdentityDbContext(DbContextOptions options) : base(options)
        {
        }

        // 在这里添加通用的DbContext逻辑，示例：
        public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
        {
            // 通用审计逻辑，比如自动设置创建/更新时间
            AddAuditFields();
            return base.SaveChangesAsync(cancellationToken);
        }

        private void AddAuditFields()
        {
            // 你的通用审计实现代码
        }
    }
}

这个基类只依赖AspNet Identity和EF Core，完全不涉及业务项目，符合Common的公共定位。

步骤2：在Domain项目中定义用户实体 #

Domain项目引用Common，创建ApplicationUser作为所有用户类型的基类，再继承它实现UserA、UserB：

using Microsoft.AspNetCore.Identity;
using YourProject.Common.Data;

namespace YourProject.Domain.Entities
{
    // 继承IdentityUser<Guid>，满足Common中泛型基类的约束
    public class ApplicationUser : IdentityUser<Guid>
    {
        // 通用用户字段示例
        public string NickName { get; set; }
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    }

    // 用户类型A，扩展专属业务字段
    public class UserA : ApplicationUser
    {
        public string CompanyName { get; set; }
        public string EmployeeId { get; set; }
    }

    // 用户类型B，扩展专属业务字段
    public class UserB : ApplicationUser
    {
        public string SchoolName { get; set; }
        public int Grade { get; set; }
    }
}

步骤3：在Infrastructure项目中实现具体的DbContext #

Infrastructure（数据访问层）引用Common和Domain，创建具体的ApplicationDbContext，继承Common中的泛型基类，添加用户子类的DbSet，并配置继承策略：

using Microsoft.EntityFrameworkCore;
using YourProject.Common.Data;
using YourProject.Domain.Entities;

namespace YourProject.Infrastructure.Data
{
    public class ApplicationDbContext : BaseIdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        {
        }

        // 添加不同用户类型的DbSet
        public DbSet<UserA> UserAs { get; set; }
        public DbSet<UserB> UserBs { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            // 配置用户继承策略，推荐用TPH（单表存储所有用户类型，通过鉴别器列区分）
            modelBuilder.Entity<ApplicationUser>()
                .HasDiscriminator<string>("UserType")
                .HasValue<ApplicationUser>("Default")
                .HasValue<UserA>("UserA")
                .HasValue<UserB>("UserB");

            // 若需要分表存储（TPT），替换为以下配置：
            // modelBuilder.Entity<UserA>().ToTable("UserAs");
            // modelBuilder.Entity<UserB>().ToTable("UserBs");
        }
    }
}

步骤4：依赖注入配置 #

在Program.cs中注册具体的ApplicationDbContext，而非Common中的泛型基类：

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// 配置AspNet Identity，绑定ApplicationUser和ApplicationDbContext
builder.Services.AddDefaultIdentity<ApplicationUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();

方案优势 #

1. 严格遵循分层依赖：Common作为基础层，不依赖任何业务项目；Domain和Infrastructure依赖Common，符合“上层依赖下层”的架构原则。
2. 灵活支持多用户类型：通过EF的继承策略，无需修改Common层即可轻松扩展UserA、UserB等不同用户类型。
3. 通用逻辑复用：Common中的BaseIdentityDbContext可封装所有DbContext的通用逻辑，避免重复代码。

内容的提问来源于stack exchange，提问作者Jose Reinaldo Ayala Arias