Entity Framework Core并行查询：.NET 6依赖注入实现方案问询

由于EF Core禁止在同一个上下文实例上执行并行查询，结合你的只读+AsNoTracking()场景，以下是几种通用的DI实现模式：

模式1：通过IServiceScopeFactory创建独立上下文范围 #

默认情况下DbContext在DI中是Scoped生命周期，无法直接在并行任务中共享。通过IServiceScopeFactory为每个并行任务创建独立的服务范围，从而获取专属的上下文实例。

public class ParallelDataService
{
    private readonly IServiceScopeFactory _scopeFactory;

    public ParallelDataService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    public async Task<List<Product>> FetchParallelProductDataAsync()
    {
        var queryTasks = new List<Task<List<Product>>>();

        // 并行执行不同查询
        queryTasks.Add(Task.Run(async () =>
        {
            using var scope = _scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            return await dbContext.Products.AsNoTracking().ToListAsync();
        }));

        queryTasks.Add(Task.Run(async () =>
        {
            using var scope = _scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            return await dbContext.Products.AsNoTracking().Where(p => p.InStock).ToListAsync();
        }));

        var results = await Task.WhenAll(queryTasks);
        return results.SelectMany(r => r).ToList();
    }
}

核心逻辑：每个并行任务都拥有独立的DbContext实例，完全规避上下文共享冲突，AsNoTracking()进一步优化只读查询的性能与内存占用。

模式2：将DbContext注册为Transient生命周期 #

如果业务场景以并行只读查询为主，可以直接修改DbContext的DI生命周期为Transient，这样每次从容器获取时都会得到全新实例，省去创建服务范围的步骤。

注册代码（Program.cs） #

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")),
    ServiceLifetime.Transient);

使用示例 #

public class TransientContextQueryService
{
    private readonly Func<AppDbContext> _dbContextFactory;

    // 通过工厂委托获取瞬态上下文
    public TransientContextQueryService(Func<AppDbContext> dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
    }

    public async Task<(List<Order>, List<Customer>)> FetchDualDataAsync()
    {
        var orderTask = Task.Run(async () =>
        {
            using var dbContext = _dbContextFactory();
            return await dbContext.Orders.AsNoTracking().ToListAsync();
        });

        var customerTask = Task.Run(async () =>
        {
            using var dbContext = _dbContextFactory();
            return await dbContext.Customers.AsNoTracking().ToListAsync();
        });

        await Task.WhenAll(orderTask, customerTask);
        return (orderTask.Result, customerTask.Result);
    }
}

注意：必须通过using语句手动释放瞬态上下文，避免数据库连接池资源泄漏。

模式3：使用官方推荐的IDbContextFactory #

EF Core提供了IDbContextFactory<T>接口，专门用于创建独立的上下文实例，无需修改原有DbContext的生命周期（保持默认Scoped即可），是官方推荐的并行/后台任务场景解决方案。

注册代码（Program.cs） #

builder.Services.AddDbContextFactory<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

使用示例 #

public class FactoryBasedParallelService
{
    private readonly IDbContextFactory<AppDbContext> _contextFactory;

    public FactoryBasedParallelService(IDbContextFactory<AppDbContext> contextFactory)
    {
        _contextFactory = contextFactory;
    }

    public async Task<List<Category>> GetCategorizedDataAsync()
    {
        var electronicsTask = Task.Run(async () =>
        {
            using var dbContext = await _contextFactory.CreateDbContextAsync();
            return await dbContext.Categories.AsNoTracking().Where(c => c.Name == "Electronics").ToListAsync();
        });

        var clothingTask = Task.Run(async () =>
        {
            using var dbContext = await _contextFactory.CreateDbContextAsync();
            return await dbContext.Categories.AsNoTracking().Where(c => c.Name == "Clothing").ToListAsync();
        });

        var results = await Task.WhenAll(electronicsTask, clothingTask);
        return results.Concat().ToList();
    }
}

优势：无需手动管理服务范围，工厂会负责上下文实例的创建逻辑，同时保留了using语句的资源释放机制。

通用注意事项 #

• 无论哪种模式，核心原则都是每个并行任务使用独立的DbContext实例，这是避免EF Core并行冲突的关键。
• 必须保留AsNoTracking()，它会关闭变更追踪，提升查询性能的同时避免多实例间的状态干扰。
• 控制并行查询的数量，避免数据库连接池耗尽，可通过调整连接字符串中的Max Pool Size参数配合优化。

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