使用Parallel.Foreach时抛出InvalidOperationException的解决方案咨询

报错的核心原因是：EF Core的DbContext实例不是线程安全的，而你的UnitOfWorkFactory注入的是Scoped生命周期的YourDbContext——在同一个请求范围内，所有线程共用同一个DbContext实例，Parallel.ForEach的多线程并发操作就会触发这个异常。

方案一：修改工作单元工厂，生成独立DbContext实例 #

让工厂每次创建工作单元时，都生成全新的DbContext，确保每个线程使用独立的实例：

1. 注册DbContext工厂（在Startup.cs中）：

services.AddDbContextFactory<YourDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("YourConnectionString")));

2. 重构工作单元工厂：

public interface IUnitOfWorkFactory { UnitOfWork CreateUnitOfWork(); }
public class UnitOfWorkFactory : IUnitOfWorkFactory
{
    private readonly IDbContextFactory<YourDbContext> _dbContextFactory;

    public UnitOfWorkFactory(IDbContextFactory<YourDbContext> dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
    }

    public UnitOfWork CreateUnitOfWork()
    {
        // 每次创建工作单元都生成新的DbContext
        var dbContext = _dbContextFactory.CreateDbContext();
        return new UnitOfWork(dbContext);
    }
}

3. 确保UnitOfWork正确释放DbContext：

public class UnitOfWork : IDisposable
{
    private readonly YourDbContext _dbContext;
    public IRepository<Templates> Templates { get; }

    public UnitOfWork(YourDbContext dbContext)
    {
        _dbContext = dbContext;
        Templates = new Repository<Templates>(dbContext);
    }

    public void Dispose()
    {
        _dbContext.Dispose();
    }
}

方案二：在每个线程内创建独立服务范围 #

利用.NET的依赖注入范围，让每个并行线程拥有自己的Scoped服务实例（包括DbContext）：

1. 控制器注入IServiceProvider：

private readonly IServiceProvider _serviceProvider;

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

2. 修改Parallel.ForEach调用：

var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2 };
Parallel.ForEach(result, parallelOptions, obj => 
{
    using (var scope = _serviceProvider.CreateScope())
    {
        // 每个线程从独立范围获取服务
        var myService = scope.ServiceProvider.GetRequiredService<MyService>();
        myService.SendEmails(obj);
    }
});

注：通过MaxDegreeOfParallelism限制并发数，避免数据库连接池耗尽。

方案三：提前加载模板到内存（最优性能） #

如果模板数量固定且很少，可在并行循环前一次性加载所有需要的模板到内存，循环内直接使用内存数据，彻底避免多线程访问数据库：

// 主线程提前加载模板
Templates templateAbc = null;
Templates templateXyz = null;
using (var scope = _serviceProvider.CreateScope())
{
    var unitOfWork = scope.ServiceProvider.GetRequiredService<IUnitOfWorkFactory>().CreateUnitOfWork();
    templateAbc = unitOfWork.Templates.GetAllWithNoTracking().Single(x => x.TemplateName == "abc");
    templateXyz = unitOfWork.Templates.GetAllWithNoTracking().Single(x => x.TemplateName == "xyz");
}

// 并行循环直接使用内存模板
Parallel.ForEach(result, obj => 
{
    var emailTemplate = obj.userType == 1 ? templateAbc : templateXyz;
    // 执行发送邮件逻辑，无需再访问数据库
});

• 无论哪种方案，都要严格遵守DbContext不能跨线程共享的原则；
• 并行操作数据库时，注意控制并发数，避免超出数据库连接池的承载上限；
• 只读操作推荐使用AsNoTracking()，减少EF的状态跟踪开销，提升性能。

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