如果所有配置都在 DbContext 的 OnConfiguring 方法中，如何使用 AddDbContextPool

Question

I'm using PostgreSQL and I have ApplicationDbContext like:

public class ApplicationDbContext : DbContext
{
    private readonly DatabaseSettings _databaseOptions;
    public ApplicationDbContext() { }
    public ApplicationDbContext(IOptions<DatabaseSettings> databaseOptions)
    {            
        _databaseOptions = databaseOptions.Value;
    }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.HasPostgresExtension("citext");
    }
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (_databaseOptions == null)
        {
            optionsBuilder.UseInMemoryDatabase(Guid.NewGuid().ToString());
        }
        else
        {
            optionsBuilder.UseNpgsql(_databaseOptions.ConnectionString,
            npgsqlOptionsAction: sqlOptions =>
            {
                sqlOptions.EnableRetryOnFailure(
                    maxRetryCount: _databaseOptions.MaxRetryCount,
                    maxRetryDelay: TimeSpan.FromSeconds(_databaseOptions.MaxRetryDelay),
                    errorCodesToAdd: null);
            });
        }
    }
}

That context is base for many others. I'm on a way of improvement performance and trying to use context pooling. Docs say to add polling I should:

services.AddDbContextPool<EmployeeContext>(options => options.UseNpgsql(connection));

But I want to store.UseNpgsql and other configs of DbContext in OnConfiguring method. How to achieve that?

Answer 1

Besides the debatable benefits of using it (from the docs: "has the advantage of saving some of the cost of initialization of DbContext instance" ), the DbContext pooling is simply not applicable in your scenario, because your context contains state which EF Core is unaware of:

private readonly DatabaseSettings _databaseOptions;

and the Limitations section of the documentation clearly states:

Warning!

Avoid using DbContext Pooling if you maintain your own state (for example, private fields) in your derived DbContext class that should not be shared across requests. EF Core will only reset the state that is aware of before adding a DbContext instance to the pool.

---

There is a reason why optionsAction of AddDbContextPool is required, while for AddDbContext it is optional. It's because of the aforementioned limitation, plus the additional requirement that your DbContext derived class must have single public constructor with single DbContextOptions parameter. You can easily see that by fooling the AddDbContextPool with passing empty action:

services.AddDbContextPool<ApplicationDbContext>(options => { });

but then at runtime you'll get InvalidOperationException saying

The DbContext of type 'ApplicationDbContext' cannot be pooled because it does not have a single public constructor accepting a single parameter of type DbContextOptions.

So in order to be eligible for pooling, you have to remove all these

private readonly DatabaseSettings _databaseOptions;
public ApplicationDbContext() { }
public ApplicationDbContext(IOptions<DatabaseSettings> databaseOptions)
{            
    _databaseOptions = databaseOptions.Value;
}

and add this instead

public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) { }

Now you should clearly see why what you are asking is not possible. Your OnConfiguring method requires DatabaseSettings , but there is no way you could provide it. Hence the options must be configured externally.

In other words, your requirements are mutually exclusive, hence there is no solution.

Answer 2

As an addendum to @Ivan Stoev's answer , should anyone need a way of creating reusable logic for an options instance that is then used to initialize a PooledDbContext 's configuration, they can take the following approach:

As Ivan clarified, your DbContext itself must have only a single constructor that takes in the DbContextOptions<TContext> . However, there's nothing stopping you from creating your own independent ConfigurationBuilder in the Action<DbContextOptions<TContext>> you pass to the AddDbContextPool() method. For example...

public class Program
{
    static int Main(string[] args)
    {
        var host = Host.CreateDefaultBuilder(args)
            .ConfigureServices((host, services) => {
                // Build DatabaseSettings from config just like IOptions<T> would.
                var config = host.Configuration;
                var settings = new DatabaseSettings();
                config.Bind(nameof(DatabaseSettings), settings);

                // Use settings to configure pool.
                services.AddPooledDbContextFactory<EmployeeContext>(optionsBuilder => {
                    if (settings.ConnectionString == null)
                    {
                        optionsBuilder.UseInMemoryDatabase(Guid.NewGuid().ToString());
                    }
                    else
                    {
                        optionsBuilder.UseNpgsql(settings.ConnectionString,
                        npgsqlOptionsAction: sqlOptions =>
                        {
                            sqlOptions.EnableRetryOnFailure(
                                maxRetryCount: settings.MaxRetryCount,
                                maxRetryDelay: TimeSpan.FromSeconds(settings.MaxRetryDelay),
                                errorCodesToAdd: null);
                        });
                    }
                });
                
                // Add example scoped configuration options
                services.AddOptions<MyOptions>();

                // Initialize each DbContext upon request
                services.AddScoped<EmployeeContext>(srv => {
                    var factory = srv.GetRequiredService<IDbContextFactory<EmployeeContext>>();
                    var snapshot = srv.GetRequiredService<IOptionsSnapshot<MyOptions>>();
                    var ctx = factory.CreateDbContext();

                    // ctx.SomeProperty = snapshot.Value.SomeProperty;
                    return ctx;
                });
            }).Build();
    }
}

If you really do need per-instance DbContext configuration when using a pool, then you can follow the documentation's recommendation here .

By accessing the DbContext instance through the service collection and using a registered factory method that instantiates the DbContext from the pooled IDbContextFactory<TContext> , you can then do any sort of initialization hand-off you need for code that uses your DbContext . This is especially useful when combined with IOptionsSnapshot<T> or IOptionsMonitor<T> to apply real-time configuration data to this initialization process.