AddDbContextPool in asp.net core System.InvalidOperationException

I’m using db context pooling in a Asp.Net core MVC application. When I launch multiple simultaneous requests I get an error :

Exception message: System.InvalidOperationException occurred in Microsoft.EntityFramework.Core.dll
A second operation started on this context before a previous operation completed. Any instance members are not guaranteed to be thread safe.

or 
Exception message: System.ObjectDisposedException: 'Cannot access a disposed object.

code;
IQueryable<TEntity> query = DbSet;
            if (filter != null)
                query = query.Where(filter); // exception occurs here

Maybe I’m not using DbContext pooling the right way…

Steps to reproduce

I launch mutiple requests in browser to the same web api controller method, which retrieves some data from the database.

 // Dependency injection is configured in Startup as follows
    services.AddScoped<IMyDbContext>(provider => provider.GetService<MyDbContext>());

// if I use service.AddScoped<IMyDbContext,MyDbContext>();
//  I get the impression db context pooling is not working, 
//  but I don't get the exception message either.

// db context pooling in Startup class
   services.AddDbContextPool<MyDbContext>(options =>
            {
                string connectionString = Configuration.GetConnectionString("MyConnection");
                options.UseSqlServer(connectionString);
            },10);

Further technical details

EF Core version:Microsoft.EntityFrameworkCore.SqlServer" Version=“2.0.0” Database Provider: Microsoft.EntityFrameworkCore.SqlServer Operating system: Win10 IDE: Visual Studio 2017

[ajcvickers]

@rekna1 I was actually able to reproduce this in a console application, so no need to dig further.

Note for triage: Works fine when AddDbContextPool is replaced by AddDbContext

public interface IMyDbContext
{
    DbSet<Foo> Foos { get; set; }
}

public class MyDbContext : DbContext, IMyDbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options) 
        : base(options)
    {
    }

    public DbSet<Foo> Foos { get; set; }
}

public class Foo
{
    public int Id { get; set; }
}

public class Program
{
    public static void Main()
    {
        var services = new ServiceCollection()
            .AddScoped<IMyDbContext>(provider => provider.GetService<MyDbContext>())
            .AddDbContextPool<MyDbContext>(options =>
            {
                options.UseSqlServer(
                    @"Server=(localdb)\mssqllocaldb;Database=Test;Trusted_Connection=True;ConnectRetryCount=0");
            })
            .BuildServiceProvider();

        using (var scope = services.CreateScope())
        {
            var context = (DbContext)scope.ServiceProvider.GetService<IMyDbContext>();
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();
        }

        Parallel.For(0, 100, s =>
        {
            using (var scope = services.CreateScope())
            {
                var context = scope.ServiceProvider.GetService<IMyDbContext>();

                Console.WriteLine("Using " + context.GetHashCode());
                context.Foos.Add(new Foo());
                ((DbContext) context).SaveChanges();
                var _ = context.Foos.ToList();
            }
        });
    }
}

[ajcvickers]

@anpete Yes, but I think you knew that by now. With regard to getting disposed twice, the IDisposable interface explicitly allows that, so I think it’s something we have to handle. From MSDN:

If an object’s Dispose method is called more than once, the object must ignore all calls after the first one. The object must not throw an exception if its Dispose method is called multiple times. Instance methods other than Dispose can throw an ObjectDisposedException when resources are already disposed.