如何使用存储库模式在 EF Core 3.0 中进行并行异步查询？

Question

我有类似的存储库

public interface IEmployeeRepository
{
  Task<EmployeeSettings> GetEmployeeSettings(int employeeId);
  Task<ICollection<DepartmentWorkPosition>> GetWorkPositions(int employeeId);
}

存储库的构造函数（DbContext 注入）：

public EmployeeRepository(EmployeeDbContext dbContext)
{
  _dbContext = dbContext;
}

并在 EF Core 2.0 中调用它

var settingsTask = _employeeRepository
    .GetEmployeeSettings(employeeId.Value);

var workPositionsTask = _employeeRepository
    .GetWorkPositions(employeeId.Value);

await Task.WhenAll(settingsTask, workPositionsTask);

// do other things...

问题：

在 EF Core 3.0 中存在 InvalidOperationException：在前一个操作完成之前在此上下文上启动了第二个操作...

DbContext 是在 ConfigureServices 中注册的

services.AddDbContext<EmployeeDbContext>(ServiceLifetime.Transient);

教程如下： Entity Framework Core 不支持在同一个 DbContext 实例上运行多个并行操作。

但是！如何在异步存储库中使用它？

Answer 1

如何在异步存储库中使用它？

每个存储库只能同时有一个异步请求。如果您一次需要多个存储库，那么您需要多个存储库。这可能需要您将存储库 factory 注入到您的类型中。

Answer 2

使用工厂和显式实例化上下文。

Startup.cs

//classical dbcontext registration
services.AddDbContext<TestDB>(
            options => options.UseSqlServer(
                Configuration.GetConnectionString("Test")));

//factory
//in case we want parallellize more queries at the same request, we can't use the same connection. So, because dbcontext is instantiate at request time this would  generate exception, so we need to use factory and explicit "using" to explicitly manage dbcontext lifetime
var optionsBuilder = new DbContextOptionsBuilder<TestDB>();
        optionsBuilder.UseSqlServer(Configuration.GetConnectionString("Test"));
        services.AddSingleton(s => new Func<TestDB>(() => new TestDB(optionsBuilder.Options)));

服务类

public class TestService
{
    private readonly TestDB _testDb;
    private readonly Func<TestDB> _testDbfunct;

    public TestService(TestDB testDb, Func<TestDB> testDbfunct)
    {
        _testDb = testDb;
        _testDbfunct = testDbfunct;
    }

    //mixed classical request dbcontext and factory approaches
    public async Task<string> TestMultiple(int id, bool newConnection = false) //we need to add optional newConnection parameter and the end of other parameters
    {
        //use request connection (_testDb) if newconnection is false, otherwise instantiate a new connection using factory. null inside "using" means that "using" is not used
        //use newconnection = true if you want run parallel queries, so you need different connection for each one
        TestDB testDb = _testDb;
        using (newConnection ? testDb = _testDbfunct() : null)
        {
            return await (from t in testDb.Table where t.id == id select t.code).FirstOrDefaultAsync();

        }
    }
}

测试类

    //instantiate dbcontext for each call, so we can parallellize
    [TestMethod]
    public async Task TestMultiple()
    { 
        //test1 and test2 starts in parallel without test2 that need to wait the end of test1. For each one a Task in returned
        var test1 = _testService.TestMultiple(1,true);
        var test2 = _testService.TestMultiple(2,true);

        //wait test1 and test2 return
        string code1 = await test1;
        string code2 = await test2;

    }
    
    //use request dbcontext
    [TestMethod]
    public async Task TestClassic()
    {
        string code = await _testService.TestMultiple(3);

    }

注意：在新的 .net core 5 中，您可以使用内置 AddDbContextFactory 而不是像我的示例中那样创建自定义工厂

Answer 3

只写：

var settings = await _employeeRepository.GetEmployeeSettings(employeeId.Value);
var workPositions = await _employeeRepository.GetWorkPositions(employeeId.Value);

是的。 EF Core 不支持在同一个上下文实例上运行多个并行操作。在开始下一个操作之前，您应该始终等待操作完成。这通常通过在每个异步操作上使用 await 关键字来完成。 看https://docs.microsoft.com/en-us/ef/core/querying/async