IServiceProviderFactory not replacing ServiceProvider

[dazinator]

I am starting with a vanilla aspnet core 3.1 web api project.

Full code below. I am attempting to substitute the default ServiceProvider with my own decorated version. However, it seems that even though my factory is called, the IApplicationBuilder.Services is not set to my IServiceProvider concrete type when the middleware pipeline is configured, and also if I inject IServiceProvider into a controller, it still seems to be the frameworks type that is being used.

Here is a complete code sample showing the issue, the two Debug.Asserts()'s are being hit and I would expect them not to be:

  public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();                 
                })
            .UseServiceProviderFactory(new TestServiceProviderFactory());
    }

    public class TestServiceProviderFactory : IServiceProviderFactory<IServiceCollection>
    {
        public IServiceCollection CreateBuilder(IServiceCollection services)
        {
            return services;
        }

        public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilder)
        {
            // decorate the built-in ServiceProvider.
            var inner = containerBuilder.BuildServiceProvider();
            return new TestServiceProvider<ServiceProvider>(inner);
        }
    }

    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            var sp = app.ApplicationServices;
            Debug.Assert(sp.GetType() == typeof(TestServiceProvider<ServiceProvider>)); // fails

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }

    public class TestServiceProvider<TInnerProvider> : IServiceProvider
       where TInnerProvider : IServiceProvider, IDisposable
    {
        private readonly IServiceProvider inner;

        public TestServiceProvider(IServiceProvider inner)
        {
            this.inner = inner;
        }

        public object GetService(Type serviceType)
        {
            if (serviceType == typeof(IServiceProvider))
            {
                return this;
            }
            return inner.GetService(serviceType);
        }
    }

    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherForecastController> _logger;
        private readonly IServiceProvider sp;

        public WeatherForecastController(ILogger<WeatherForecastController> logger, IServiceProvider sp)
        {
            _logger = logger;
            Debug.Assert(sp.GetType() == typeof(TestServiceProvider<ServiceProvider>)); // fails
        }

        [HttpGet]
        public IEnumerable<WeatherForecast> Get()
        {
            var rng = new Random();
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = rng.Next(-20, 55),
                Summary = Summaries[rng.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }

        public int TemperatureC { get; set; }

        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

        public string Summary { get; set; }
    }

Am I missing some other key step to replacing the in-built service provider here?

[dazinator]

It seems the IApplicationBuilderFactory and the IHost don't get injected with the IServiceProvider that is returned as the result from the above TestServiceProviderFactory. This in turn means IApplicationBuilder.ApplicationServices is not set to that IServiceProvider either.

[dazinator]

I believe that trying to decorate the native ServiceProvider is not possible. When the native ServiceProvider is built, if any services have IServiceProvider or IServiceScopeFactory as constructor arguments (as is the case with the IHost and IApplicationBuilder implementations) - the service provider directly maps those argument to its own internal types via some Callsite / CallsiteFactory stuff. IServiceProviderFactory is completely irrelevant to this equation.

I'd like for all services registered for DI and with IServiceProvider as a constructor arg (or IServiceScopeFactory) to recieve my decorator IServiceProvider / IServiceScopeFactory, so I can intercept any calls for creating new scopes and keep track of them for example. Any ideas on whether this is achievable?

[akovac35]

I have the same issue and can confirm the sample code has the described effect.

[dazinator]

I've worked around this issue, as I assume there will be no movement on it.

The framework has a bit of a pain area, stemming from:

1. You can't dispose of a disposable IServiceProvider safely unless you can account for all of its DI scopes and ensure they are all disposed of first (as singletons may be in use via those DI scopes). For example these DI scopes that must be accounted for, could be for active requests, or for background jobs (hosted service) or anywhere else a scope might be created. Its not enough just to track requests, or just to track background jobs, you have to ensure all DI scopes are tracked.
2. You can't account for all DI scopes robustly because any service registered for DI (like some of the default services, or perhaps third party .AddXyz() methods) could be accepting an IServiceProvider in its constructor and later using it to CreateScope(). There is no opportunity to track this scope creation.. Decorating the IServiceProvider to intercept calls to CreateScope() in order to track scopes should work on paper, but in practice, it doesnt work as easily as it should do when using the Native service provider, because the native service provider always injects itself into such services that have that constructor param - not giving you any opportunity to create / inject the decorated version into the service. The workaround for this approach is to find and to override all such service registrations with your own factory method version of the registration, that will create the service but passing your decorator in to its constructor instead. This relies on tracking all such service registrations down First (such as IHost, IApplicationBuilderFactory etc).

Background context: in my scenario I am dealing with a multitenant application, and each tenant has its own IServiceProvider. I am looking to be able to restart a tenant without impacting others, by disposing and rebuilding that tenabr service provider - for example to load that tenants updated plugins, without impacting other tenants by stopping the entire application. I have a working POC now, but this is an active pain point.

[davidfowl]

No this isn't possible. You need to implement a real container to get the transitive graph to work. I would use another container that supports these kinds of hooks.

[dazinator]

@davidfowl OK thanks