I’m using Entity Framework Core with the Cosmos DB provider in Azure Functions, and when two HTTP-triggered functions are invoked simultaneously, I get an exception stating that the DbContext was accessed from another thread.

Here’s my setup:

• DbContext is registered and configured using the AddDbContext() method.
• A UnitOfWork class uses this DbContext, and it’s registered as a scoped service.
• Several MediatR RequestHandler classes depend on this UnitOfWork and are registered using the RegisterServicesFromAssembly() method.

Program.cs

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        services.AddDbContext<MyDbContext>(options =>
        {
            options.UseCosmos(
                "https://your-cosmosdb-uri",
                "your-cosmosdb-key",
                "your-database-name"
            );
        }, ServiceLifetime.Transient);

        services.AddTransient<IUnitOfWork, UnitOfWork>();

        services.AddMediatR(cfg =>
            cfg.RegisterServicesFromAssembly(typeof(Program).Assembly)
        );
    })
    .Build();

host.Run();

MyFunctions.cs

public class MyFunctions
{
    private readonly IMediator _mediator;

    public MyFunctions(IMediator mediator)
    {
        _mediator = mediator;
    }

    [FunctionName("MyFunctionOne")]
    public async Task<IActionResult> RunOne(
        [HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequest req,
        CancellationToken cancellationToken)
    {
        var result = await _mediator.Send(new MyRequest(), cancellationToken);
        return new OkObjectResult(result);
    }

    [FunctionName("MyFunctionTwo")]
    public async Task<IActionResult> RunTwo(
        [HttpTrigger(AuthorizationLevel.Function, "get"] HttpRequest req,
        CancellationToken cancellationToken)
    {
        var result = await _mediator.Send(new MyRequest(), cancellationToken);
        return new OkObjectResult(result);
    }
}

UnitOfWork.cs

public class UnitOfWork : IUnitOfWork
{
    private readonly MyDbContext _context;
    private readonly MyRepository _repo;
    
    public UnitOfWork(MyDbContext context)
    {
        _context = context;
        _repo = new MyRepository(_context);
    }

    public MyRepository ProductRepository { get => _repo; }
}

MyRequestHandler.cs

public class MyRequestHandler : IRequestHandler<MyRequest, MyResponse>
{
    private readonly IUnitOfWork _unitOfWork;

    public MyRequestHandler(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }

    public async Task<MyResponse> Handle(MyRequest request, CancellationToken cancellationToken)
    {
        // Perform operations using UnitOfWork or any other logic
        await _unitOfWork.SaveChangesAsync(cancellationToken);

        // Create and return the response
        return new MyResponse
        {
            Result = $"Processed: {request.Data}"
        };
    }
}

Any insights into the cause of this threading issue?

I’ve explicitly tried both Scoped and Transient lifetimes in the AddDbContext() call, but the problem persists.