asp.net core A second operation started on this context before a previous operation completed

Question

I have an ASP.Net Core 2 Web application.

I'm trying to create a custom routing Middleware, so I can get the routes from a database.

In ConfigureServices() I have:

services.AddDbContext<DbContext>(options => 
    options.UseMySQL(configuration.GetConnectionString("ConnectionClient")));
services.AddScoped<IServiceConfig, ServiceConfig>();

In Configure():

app.UseMvc(routes =>
{
    routes.Routes.Add(new RouteCustom(routes.DefaultHandler);
    routes.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}");
});

In the RouteCustom

public class RouteCustom : IRouteCustom
{
    private readonly IRouter _innerRouter;
    private IServiceConfig _serviceConfig;

    public RouteCustom(IRouter innerRouter)
    {
        _innerRouter = innerRouter ?? throw new ArgumentNullException(nameof(innerRouter));
    }

    public async Task RouteAsync(RouteContext context)
    {
        _serviceConfig = context.HttpContext
            .RequestServices.GetRequiredService<IServiceConfig>();
        /// ...
        // Operations inside _serviceConfig to get the route
    }

    public VirtualPathData GetVirtualPath(VirtualPathContext context)
    {
        _serviceConfig = context.HttpContext
            .RequestServices.GetRequiredService<IServiceConfig>();
        // ...
        // Operations inside _serviceConfig to get the route
    }
}

The IServiceConfig it is just a class where I access the database to get data, in this case the routes, but also other configuration data I need for the application.

public interface IServiceConfig
{
    Config GetConfig();
    List<RouteWeb> SelRoutesWeb();
}

public class ServiceConfig : IServiceConfig
{
    private readonly IMemoryCache _memoryCache;
    private readonly IUnitOfWork _unitOfWork;
    private readonly IServiceTenant _serviceTenant;

    public ServiceConfig(IMemoryCache memoryCache,
                        IUnitOfWork unitOfWork,
                        IServiceTenant serviceTenant)
    {
        _memoryCache = memoryCache;
        _unitOfWork = unitOfWork;
        _serviceTenant = serviceTenant;
    }


    public Config GetConfig()
    {
        var cacheConfigTenant = Names.CacheConfig + _serviceTenant.GetId();

        var config = _memoryCache.Get<Config>(cacheConfigTenant);
        
        if (config != null) 
            return config;

        config = _unitOfWork.Config.Get();
        _memoryCache.Set(cacheConfigTenant, config,
            new MemoryCacheEntryOptions() 
            { 
                SlidingExpiration = Names.CacheExpiration 
            });

        return config;
    }


    public List<RouteWeb> SelRoutesWeb()
    {
        var cacheRoutesWebTenant = Names.CacheRoutesWeb + _serviceTenant.GetId();

        var routesWebList = _memoryCache.Get<List<RouteWeb>>(cacheRoutesWebTenant);
        
        if (routesWebList != null) 
            return routesWebList;

        routesWebList = _unitOfWork.PageWeb.SelRoutesWeb();
        _memoryCache.Set(cacheRoutesWebTenant, routesWebList, 
            new MemoryCacheEntryOptions() 
            { 
                SlidingExpiration = Names.CacheExpiration 
            });

        return routesWebList;
    }
    
}

The problem is I'm getting this message when I test with multiple tabs opened and try to refresh all at the same time: "A second operation started on this context before a previous operation completed"

I'm sure there is something I'm doing wrong, but I don't know what. It has to be a better way to access the db inside the custom route middleware or even a better way for doing this.

For example, on a regular Middleware (not the routing one) I can inject the dependencies to the Invoke function, but I can't inject dependencies here to the RouteAsync or the GetVirtualPath().

What can be happening here?

Thanks in advance.

---

UPDATE These are the exceptions I'm getting.

An unhandled exception occurred while processing the request. InvalidOperationException: A second operation started on this context before a previous operation completed. Any instance members are not guaranteed to be thread safe.

And this one:

An unhandled exception occurred while processing the request. MySqlException: There is already an open DataReader associated with this Connection which must be closed first.

This is the UnitOfWork

public interface IUnitOfWork : IDisposable
{
    ICompanyRepository Company { get; }
    IConfigRepository Config { get; }
    
    // ...

    void Complete();
}


public class UnitOfWork : IUnitOfWork
{
    private readonly DbContext _context;

    public UnitOfWork(DbContext context)
    {
        _context = context;

        Company = new CompanyRepository(_context);
        Config = new ConfigRepository(_context);
        // ...
    }

    public ICompanyRepository Company { get; private set; }
    public IConfigRepository Config { get; private set; }
    
    // ...

    public void Complete()
    {
        _context.SaveChanges();
    }

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

}

UPDATE 2

After reviewing the comments and making a lot of tests, the best clue I have is when I remove the CustomRoute line the problem disappear. Removing this line from Configure function on Startup.cs

routes.Routes.Add(new RouteCustom(routes.DefaultHandler));

Also I have tried removing, first the RouteAsync and then the GetVirtualPath() methods, but if one of those is present I get an error, so it is clear that the problem is in this CustomRoute class.

In the TenantMiddleware, which is called first for any request, I'm injecting the UnitOfWork and I have no problem. This Middleware is create in the Configure function:

app.UseMiddleware<TenantMiddleware>();

And inside, I'm injecting the UnitOfWork, and using it on every request, like this:

public async Task Invoke(HttpContext httpContext, IServiceTenant serviceTenant)
{
    // ...performing DB operations to retrieve the tenent's data.
}

public class ServiceTenant : IServiceTenant
{
    public ServiceTenant(IHttpContextAccessor contextAccessor, 
                        IMemoryCache memoryCache,
                        IUnitOfWorkMaster unitOfWorkMaster)
    {
            _unitOfWorkMaster = unitOfWorkMaster;
    }

    // ...performing DB operations
}

SO, the problem with the CustomRoute is I can't inject the dependencies by adding to the Invoke function like this:

public async Task Invoke(HttpContext httpContext, IServiceTenant serviceTenant)

So I have to call the corresponding Service (Inside that service I inject the UnitOfWork and perform the DB operations) like this, and I think this can be the thing that is causing problems:

public async Task RouteAsync(RouteContext context)
{
    _serviceConfig = context.HttpContext
        .RequestServices.GetRequiredService<IServiceConfig>();
    // ....
}

because this is the only way I know to "inject" the IServiceConfig into the RouteAsync and GetVirtualPath()...

Also, I'm doing that in every controller since I'm using a BaseCOntroller, so I decide which os the injection services I use...

public class BaseWebController : Controller
{
    private readonly IMemoryCache _memoryCache;
    private readonly IUnitOfWork _unitOfWork;
    private readonly IUnitOfWorkMaster _unitOfWorkMaster;
    private readonly IServiceConfig _serviceConfig;
    private readonly IServiceFiles _serviceFiles;
    private readonly IServiceFilesData _serviceFilesData;
    private readonly IServiceTenant _serviceTenant;

    public BaseWebController(IServiceProvider serviceProvider)
    {
        _memoryCache = serviceProvider.GetRequiredService<IMemoryCache>();
        _unitOfWork = serviceProvider.GetRequiredService<IUnitOfWork>();
        _unitOfWorkMaster = serviceProvider.GetRequiredService<IUnitOfWorkMaster>();
        _serviceConfig = serviceProvider.GetRequiredService<IServiceConfig>();
        _serviceFiles = serviceProvider.GetRequiredService<IServiceFiles>();
        _serviceFilesData = serviceProvider.GetRequiredService<IServiceFilesData>();
        _serviceTenant = serviceProvider.GetRequiredService<IServiceTenant>();        
    }
}

And then in every controller, instead of referencing all of the injected services, I can do it only for those I need, like this:

public class HomeController : BaseWebController
{
    private readonly IUnitOfWork _unitOfWork;

    public HomeController(IServiceProvider serviceProvider) : base(serviceProvider)
    {
        _unitOfWork = serviceProvider.GetRequiredService<IUnitOfWork>();
    }

    public IActionResult Index()
    {
        // ...
    }
}

I don't know if this has something to do with my problem, but I'm just showing you what I think can be the problem, so you can have more information.

Thanks.

UPDATE 3

This is the code of the db to retrieve the routes:

public class PageWebRepository : Repository<PageWeb>, IPageWebRepository
{
    public PageWebRepository(DbContext context) : base(context) { }


    public List<RouteWeb> SelRoutesWeb()
    {
        return Context.PagesWebTrs
            .Include(p => p.PageWeb)
            .Where(p => p.PageWeb.Active)
            .Select(p => new RouteWeb
            {
                PageWebId = p.PageWebId,
                LanguageCode = p.LanguageCode,
                Route = p.Route,
                Regex = p.PageWeb.Regex.Replace("<route>", p.Route),
                Params = p.PageWeb.Params,
                Area = p.PageWeb.Area,
                Controller = p.PageWeb.Controller,
                Action = p.PageWeb.Action,
                Type = p.PageWeb.Type,
                Sidebar = p.PageWeb.Sidebar,
                BannerIsScript = p.PageWeb.BannerIsScript,
                Title = p.Title,
                Description = p.Description,
                Keywords = p.Keywords,
                ScriptHead = p.ScriptHead,
                ScriptBody = p.ScriptBody,
                BannerScript = p.BannerScript,
                BannerUrl = p.BannerUrl,
            })
            .ToList();
    }
}

Where PagesWebTrs are the translations of the pages (multi language) and PagesWeb is the main table.

Answer 1

This issue is indeed within the route middleware.

Per definition, a middleware is a singleton, so a single instance handles all requests. This results into the instance state (the IServiceConfigwith hooked up DbContext) being accessed and changed by multiple simultaneous requests; it's a well disguished classical concurrency issue.

An example.

Request A executes RouteAsync, sets the _serviceConfig and executes a query on the DbContext. Nano seconds (or less :)) later, request B does the same. While request B's query is being executed, request A executes GetVirtualPath, but this time on the DbContext set by request B. This results in a second query being executed on the DbContext of request B which still has one running and you get the mentionned error.

The solution is to prevent shared state, by retrieving the IServiceConfig at the start of each method.

As you already said, getting such a dependency injected via the Invoke method does not work; the Invokemethod does not get executed.

Here below is the reworked RouteCustom.

public class RouteCustom : IRouteCustom
{
    private readonly IRouter _innerRouter;

    public RouteCustom(IRouter innerRouter)
    {
        _innerRouter = innerRouter ?? throw new ArgumentNullException(nameof(innerRouter));
    }

    public async Task RouteAsync(RouteContext context)
    {
        var serviceConfig = context.HttpContext.RequestServices.GetRequiredService<IServiceConfig>();
        // ...

    }

    public VirtualPathData GetVirtualPath(VirtualPathContext context)
    {
        var serviceConfig = context.HttpContext.RequestServices.GetRequiredService<IServiceConfig>();
        // ...

    }
}