如何为多DbContext模块化ASP.NET应用设计通用IInboxRepository

一、当前实现的核心问题 #

你当前的泛型IInboxRepository<T>与具体DbContext强绑定，导致每个模块需要单独注册对应泛型仓库，事件处理器也必须显式指定TDbContext类型。这种方式在模块或事件数量增加时，会产生大量重复的注册代码，无法实现动态解析模块DbContext的需求，扩展性极差。

二、动态解析模块DbContext的设计方案 #

1. 抽象模块DbContext契约 #

首先定义统一的模块DbContext接口，让所有模块的DbContext实现该接口，明确模块标识与收件箱表：

// 基础DbContext接口（保留你原有的定义）
public interface IDbContext
{
    DbSet<TEntity> Set<TEntity>() where TEntity : class;
    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
}

// 模块专属DbContext接口，增加模块标识与收件箱集合
public interface IModuleDbContext : IDbContext
{
    string ModuleName { get; }
    DbSet<InboxMessage> InboxMessages { get; }
}

// 通用收件箱实体
public class InboxMessage
{
    public Guid Id { get; set; }
    public string EventType { get; set; } = string.Empty;
    public string EventData { get; set; } = string.Empty;
    public DateTimeOffset ReceivedAt { get; set; }
    public bool IsProcessed { get; set; }
}

2. 重构非泛型IInboxRepository #

去掉泛型约束，改为通过模块标识动态获取对应DbContext：

public interface IInboxRepository
{
    Task AddAndSaveAsync(string moduleName, IIntegrationEvent integrationEvent, CancellationToken cancellationToken = default);
}

public sealed class InboxRepository(IModuleDbContextFactory dbContextFactory) : IInboxRepository
{
    private readonly IModuleDbContextFactory _dbContextFactory = dbContextFactory;

    public async Task AddAndSaveAsync(string moduleName, IIntegrationEvent integrationEvent, CancellationToken cancellationToken = default)
    {
        // 通过工厂获取对应模块的DbContext
        var dbContext = _dbContextFactory.GetDbContext(moduleName);
        
        // 序列化事件并构建收件箱消息
        var inboxMessage = new InboxMessage
        {
            Id = Guid.NewGuid(),
            EventType = integrationEvent.GetType().FullName!,
            EventData = JsonSerializer.Serialize(integrationEvent),
            ReceivedAt = DateTimeOffset.UtcNow,
            IsProcessed = false
        };

        dbContext.InboxMessages.Add(inboxMessage);
        await dbContext.SaveChangesAsync(cancellationToken);
    }
}

3. 实现DbContext工厂类 #

专门负责根据模块标识解析对应的DbContext，解耦仓库与DI容器：

public interface IModuleDbContextFactory
{
    IModuleDbContext GetDbContext(string moduleName);
}

public sealed class ModuleDbContextFactory(IServiceProvider serviceProvider) : IModuleDbContextFactory
{
    private readonly IServiceProvider _serviceProvider = serviceProvider;

    public IModuleDbContext GetDbContext(string moduleName)
    {
        var dbContext = _serviceProvider.GetServices<IModuleDbContext>()
            .FirstOrDefault(ctx => ctx.ModuleName.Equals(moduleName, StringComparison.OrdinalIgnoreCase));
        
        if (dbContext == null)
            throw new InvalidOperationException($"未找到模块[{moduleName}]对应的DbContext");
        
        return dbContext;
    }
}

4. 模块DbContext实现 #

每个模块的DbContext继承并实现IModuleDbContext，同时配置专属收件箱表：

// 模块A的DbContext
public class ModuleADbContext : DbContext, IModuleDbContext
{
    public string ModuleName => "ModuleA";
    public DbSet<InboxMessage> InboxMessages { get; set; } = null!;
    // 模块A专属实体集合
    public DbSet<ModuleAEntity> ModuleAEntities { get; set; } = null!;

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 配置模块专属收件箱表名，避免跨模块表冲突
        modelBuilder.Entity<InboxMessage>().ToTable("ModuleA_InboxMessages");
        // 配置模块A其他实体
        base.OnModelCreating(modelBuilder);
    }
}

5. 事件处理器与模块标识绑定 #

通过特性标记的方式，让事件与所属模块关联，实现自动解析：

// 模块标识特性
[AttributeUsage(AttributeTargets.Class)]
public class ModuleAttribute : Attribute
{
    public string ModuleName { get; }
    public ModuleAttribute(string moduleName) => ModuleName = moduleName;
}

// 标记事件所属模块
[Module("ModuleA")]
public class OrderCreatedEvent : IIntegrationEvent
{
    // 事件属性
    public Guid OrderId { get; set; }
}

然后实现通用事件处理器，自动读取特性获取模块名：

public sealed class GenericIntegrationEventHandler<TEvent>(IInboxRepository inboxRepository) 
    : IIntegrationEventHandler<TEvent>
    where TEvent : class, IIntegrationEvent
{
    private readonly IInboxRepository _inboxRepository = inboxRepository;
    private readonly string _moduleName = typeof(TEvent)
        .GetCustomAttribute<ModuleAttribute>()?
        .ModuleName ?? throw new InvalidOperationException($"事件[{typeof(TEvent).Name}]未标记模块特性");

    public async Task Handle(TEvent notification, CancellationToken cancellationToken)
    {
        await _inboxRepository.AddAndSaveAsync(_moduleName, notification, cancellationToken);
    }
}

6. DI容器注册 #

// 注册模块DbContext
services.AddDbContext<ModuleADbContext>(options => 
    options.UseSqlServer("Your_ModuleA_ConnectionString"));
services.AddDbContext<ModuleBDbContext>(options => 
    options.UseSqlServer("Your_ModuleB_ConnectionString"));

// 将模块DbContext注册为IModuleDbContext
services.AddScoped<IModuleDbContext>(sp => sp.GetRequiredService<ModuleADbContext>());
services.AddScoped<IModuleDbContext>(sp => sp.GetRequiredService<ModuleBDbContext>());

// 注册工厂与仓库
services.AddScoped<IModuleDbContextFactory, ModuleDbContextFactory>();
services.AddScoped<IInboxRepository, InboxRepository>();

// 注册通用事件处理器
services.AddScoped(typeof(IIntegrationEventHandler<>), typeof(GenericIntegrationEventHandler<>));

三、更优雅高效的替代方案 #

1. 利用MediatR Pipeline Behavior统一处理 #

无需为每个事件编写处理器，通过MediatR的管道行为，在事件处理前自动存储到收件箱：

public class InboxPipelineBehavior<TRequest, TResponse>(
    IInboxRepository inboxRepository,
    IModuleNameResolver moduleNameResolver) 
    : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IIntegrationEvent
{
    private readonly IInboxRepository _inboxRepository = inboxRepository;
    private readonly IModuleNameResolver _moduleNameResolver = moduleNameResolver;

    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
    {
        // 获取事件所属模块名
        var moduleName = _moduleNameResolver.Resolve<TRequest>();
        // 存储到收件箱
        await _inboxRepository.AddAndSaveAsync(moduleName, request, cancellationToken);
        // 继续执行后续处理器
        return await next();
    }
}

// 模块名解析器实现
public interface IModuleNameResolver
{
    string Resolve<TEvent>() where TEvent : IIntegrationEvent;
}

public class AttributeBasedModuleNameResolver : IModuleNameResolver
{
    public string Resolve<TEvent>() where TEvent : IIntegrationEvent
    {
        var attr = typeof(TEvent).GetCustomAttribute<ModuleAttribute>();
        if (attr == null)
            throw new InvalidOperationException($"事件[{typeof(TEvent).Name}]未标记模块特性");
        
        return attr.ModuleName;
    }
}

// 注册管道行为与解析器
services.AddScoped(typeof(IPipelineBehavior<,>), typeof(InboxPipelineBehavior<,>));
services.AddScoped<IModuleNameResolver, AttributeBasedModuleNameResolver>();

2. 基类DbContext减少重复代码 #

定义抽象基类DbContext，封装收件箱实体的配置，每个模块DbContext只需继承并实现模块名：

public abstract class ModuleDbContextBase : DbContext, IModuleDbContext
{
    public abstract string ModuleName { get; }
    public DbSet<InboxMessage> InboxMessages { get; set; } = null!;

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 自动配置模块专属收件箱表
        modelBuilder.Entity<InboxMessage>().ToTable($"{ModuleName}_InboxMessages");
        base.OnModelCreating(modelBuilder);
    }
}

// 模块A的DbContext简化为：
public class ModuleADbContext : ModuleDbContextBase
{
    public override string ModuleName => "ModuleA";
    public DbSet<ModuleAEntity> ModuleAEntities { get; set; } = null!;
}

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