How to properly dispose PooledDbContextFactory instance? - entity-framework

Question

Our system contains multiple databases with an equal scheme. Their connection strings are stored in a some storage, so we create a DbContext instance each time we need connect to those databases. Something like this:
public ICdsDataContext CreateContext(long storageId)
{
// get options to connect to a database (connection strings, etc)
var storageDbOptions = _storageDbOptionsFactory.Create(storageId);
// create an EF context
return CreateContext(storageDbOptions);
}
We would like to improve performance, so we want to use PooledDbContextFactory<T>. Our CreateContext method looks like this:
private CdsDataContext CreateContext(IStorageDbOptions storageDbOptions)
{
// get context factory with pooling support
var pooledDbContextFactory = GetPooledDbContextFactory(storageDbOptions);
// create and return a new context from the pool
return pooledDbContextFactory.CreateDbContext();
}
We have a lot of databases, because of that we want to cache PooledDbContext for a while. If a connection to a database is not in use for sometime, the factory for this connection string will be removed from the cache. We manually create a factory because of different databases. The lifetime of PooledDbContext could be much shorter than the application lifetime.
private PooledDbContextFactory<CdsDataContext> GetPooledDbContextFactory(IStorageDbOptions storageDbOptions)
{
// here goes some checks
...
// fetch from cache factory with pooling based on params from storageDbOptions
var cacheKey = $"cds_context_factory_{connectionString}_need_logging_{needLogging}_timeout_{commandTimeout}";
return _memoryCache.GetOrCreate(cacheKey, entry =>
{
// if not factory in cache was found, create a new one
// set TTL
entry.SlidingExpiration = CacheTtl;
// create options
var optionsBuilder = new DbContextOptionsBuilder<CdsDataContext>();
optionsBuilder
.UseNpgsql(connectionString)
.UseLazyLoadingProxies();
// return new factory
return new PooledDbContextFactory<CdsDataContext>(optionsBuilder.Options);
});
}
Of course, context is placed in using.
using (var cdsContext = _cdsDataContextFactory.CreateContext(projectInfoData.CdsStorageId))
{
// some logic goes here
}
But there is not Dispose method in PooledDbContextFactory, IDbContextPool also doesn't contains Dispose. But DbContextPool that implements IDbContextPool also implement IDiposable and IAsyncDisposable.
Do we need to manually dispose PooledDbContextFactory and it internal pool? Or there is no risks for memory and connections leaks?