Registering Transient Web API Controller with IServiceProvider leads to outofmemoryexception - asp.net-web-api

Question

I've seen numerous examples for setting up a .NET Framework Web API using the DI libraries built for .NET Core (i.e. IServiceProvider). While it all makes sense, I am seeing memory issues with my Web API Controllers. A description of this setup is shown here.
asp.net adding ApiController as service for dependency injection
IServiceProvider uses transient tracking and keeps a list of all disposables. Because the ApiController base class implements IDisposable and is setup as a Transient dependency, the list of disposables will grow indefinitely as subsequent requests are made to each controller. This will create a severely large memory problem. Transient tracking is talked about here.
https://github.com/aspnet/DependencyInjection/issues/456
My question is what is the proper way to register these controllers with the container so memory will not spiral out of control?
I need to use IServiceProvider and cannot use a third-party DI framework.
I have tried to register controllers as scoped, but receive the following error. Any help would be appreciated.
Scoped controller error message

Answer 1

The answer was to instantiate a class implementing IDependencyScope from the BeginScope() method in the DependencyResolver. This prevents a new pointer from being added to the Disposables collection and thereby eliminates the memory leak.
/// <inheritdoc />
public class DefaultDependencyResolver : IDependencyResolver
{
private readonly IServiceProvider _serviceProvider;
/// <inheritdoc />
public DefaultDependencyResolver(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
}
/// <inheritdoc />
public object GetService(Type serviceType)
{
return _serviceProvider.GetService(serviceType);
}
/// <inheritdoc />
public IEnumerable<object> GetServices(Type serviceType)
{
return _serviceProvider.GetServices(serviceType);
}
/// <inheritdoc />
public IDependencyScope BeginScope()
{
return new DefaultDependencyScope(_serviceProvider.CreateScope());
}
/// <inheritdoc />
public void Dispose()
{
//No-op
}
}
/// <inheritdoc />
public class DefaultDependencyScope : IDependencyScope
{
private readonly IServiceScope _serviceScope;
/// <inheritdoc />
public DefaultDependencyScope(IServiceScope serviceScope)
{
_serviceScope = serviceScope;
}
/// <inheritdoc />
public void Dispose()
{
_serviceScope.Dispose();
}
/// <inheritdoc />
public object GetService(Type serviceType)
{
return _serviceScope.ServiceProvider.GetService(serviceType);
}
/// <inheritdoc />
public IEnumerable<object> GetServices(Type serviceType)
{
return _serviceScope.ServiceProvider.GetServices(serviceType);
}
}
and then register the dependency resolver from the API configuration
//Register controllers with container
foreach (var type in typeof(WebApiConfig).Assembly.GetExportedTypes()
.Where(t => !t.IsAbstract && !t.IsGenericTypeDefinition)
.Where(t => typeof(ApiController).IsAssignableFrom(t)))
{
services.AddTransient(type);
}
//Link DI in application to container
var provider = services.BuildServiceProvider();
config.DependencyResolver = new DefaultDependencyResolver(provider);
In my case, I didn't NEED to register any dependencies as singletons. If this is required, there may be additional code needed to conditionally return a scope based on the type.