复用EF仓储基类：Worker项目单例上下文线程安全性验证

我希望在ASP.NET Web API和Worker项目中复用同一仓储基类。由于Worker项目无法使用作用域服务，因此需确保实现具备线程安全性。

请问在将上下文注册为单例时，以下示例实现是否具备线程安全性？

基础仓储类（仅展示部分代码） #

public class RepositoryBase<TContext> : IRepositoryBase<TContext> where TContext : DbContext, new()
{
    public Func<TContext> GetContext;

    public RepositoryBase()
    {
        GetContext = GetCurrentContext;
    }

    protected TContext GetCurrentContext()
    {
        return new TContext();
    }

    public IQueryable<TEntity> QueryAll<TEntity>() where TEntity : class
    {
        return GetDbSet<TEntity>().AsQueryable();
    }

    public void AddRange<TEntity>(IEnumerable<TEntity> entities) where TEntity : class
    {
        GetDbSet<TEntity>().AddRange(entities);
    }

    public async Task SaveChangesAsync()
    {
        await Context.SaveChangesAsync();
    }
}

Worker仓储基类 #

public class WorkerRepositoryBase<TContext> : RepositoryBase<TContext>, IWorkerRepositoryBase<TContext> where TContext : DbContext, new()
{
    private readonly IServiceProvider _serviceProvider;

    public WorkerRepositoryBase(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    protected override TContext GetCurrentContext()
    {
        using var scope = _serviceProvider.CreateScope();
        return scope.ServiceProvider.GetRequiredService<TContext>();
    }
}

首先明确：EF Core的DbContext本身不具备线程安全性，官方明确要求每个DbContext实例必须是短期、线程唯一的，绝对不能跨线程共享，也不能以单例模式长期持有。

针对你的实现，存在两个核心问题：

1. Context被提前释放
   Worker仓储基类的GetCurrentContext方法中，创建的作用域是用using包裹的，当方法返回Context时，作用域会立即被释放，对应的DbContext实例也会被Dispose。后续对这个Context的任何操作（比如SaveChangesAsync）都会抛出ObjectDisposedException。

2. 单例Context的线程安全问题
   即便你调整作用域逻辑避免Context被提前释放，若将DbContext注册为单例，所有线程都会共享同一个Context实例。这会导致并发操作时的实体状态混乱、查询结果异常、SaveChanges时的竞态条件等各种不可预期的问题，完全违反线程安全要求。

正确的实现方式 #

不要将DbContext注册为单例，而是保持其Scoped注册（这也是EF Core的默认推荐方式）。在Worker项目中，通过创建临时作用域来限定DbContext的生命周期，确保每次数据库操作都使用独立的Context实例：

public class WorkerRepositoryBase<TContext> : IWorkerRepositoryBase<TContext> where TContext : DbContext
{
    private readonly IServiceProvider _serviceProvider;

    public WorkerRepositoryBase(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    // 封装带保存操作的异步方法
    public async Task ExecuteWithSaveAsync(Func<TContext, Task> operation)
    {
        using var scope = _serviceProvider.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<TContext>();
        
        await operation(context);
        await context.SaveChangesAsync();
    }

    // 封装带返回值和保存操作的异步方法
    public async Task<TResult> ExecuteWithSaveAsync<TResult>(Func<TContext, Task<TResult>> operation)
    {
        using var scope = _serviceProvider.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<TContext>();
        
        var result = await operation(context);
        await context.SaveChangesAsync();
        return result;
    }

    // 封装单独的查询方法（无需保存）
    public async Task<List<TEntity>> QueryAllAsync<TEntity>() where TEntity : class
    {
        using var scope = _serviceProvider.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<TContext>();
        
        return await context.Set<TEntity>().ToListAsync();
    }
}

核心思路 #

• 每个数据库操作（或一组相关操作）都在独立的作用域内完成，确保DbContext实例的生命周期与操作周期完全绑定。
• 避免跨作用域传递DbContext实例，防止实例被意外释放或共享。
• 保持DbContext的Scoped注册，遵循EF Core的设计规范，从根源上保证线程安全。

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