Singleton depenendency injected service depending on scoped injected service

[jhudsoncedaron]

We had this issue this past week where we discovered that a particular singleton service would die after several hours. On tracing it to the bottom we found the impossibility; the singleton service was receiving a scoped service as a dependency. The dependency injector just lets you do this.

The correct fix was as expected, pass the scoped dependency in from the controller (on each of the handful of method calls that cared) rather than the constructor of the service.

I'm left wondering if the dependency injector should have caught this mistake or not.

Basically it looked like this (boneheaded mistake):

class MapService : BaseService {
    public MapService(Lazy<Sesssion> session) : base(session) {}

    private Dictionary<...> ServiceData;

    public MapModel GetModel(int mapId) {
        var map = LoadMapFromDb(mapId, Session);
        return MapModel.Create(map);
    }
    /* lots more methods */
}

services.AddSingleton<MapService>();
services.AddScoped(Lazy<Session>, new Lazy<Session(() => { /* does something with HttpRequest */ }));

This happened because the new guy missed it; the two services.Add lines were in the same function but not the same screen.
I'm just wondering if DI itself or an analyzer should have caught this; or on the flip side there's a real use for this construct.

[gfoidl]

For Development environment the DI container does validation and should throw (fail early) in that case.
For non-DEV this is disabled by default (for perf reasons).

This is documented in Scope validation, Scope validation, and Scope validation (3x the same title, but different targets).

Die you try this? What is missing here?

[jhudsoncedaron]

So that's interesting. I must now report that we observe that it is not working. However our startup code dates from NET Core 1.1's templates.

Service startup code:

    IServiceProvider IStartup.ConfigureServices(IServiceCollection services)
    {
        ConfigureServices(services);
        return services.BuildServiceProvider();
    }

    // Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services) {
        var builder = services.AddMvc();

        services.Configure<IISServerOptions>((options) => options.AllowSynchronousIO = true);
        services.AddResponseCompression(options => {
            // compression for https is generally a potential vulnerability
            // we mitigate using a random length header set in middleware
            options.EnableForHttps = true;
        });

        //json serializer settings
        builder.AddNewtonsoftJson(jsonOptions => {
            /* snip */
        });

        services.AddHttpClient();
        //services.AddSingleton<IHostingEnvironment>(HostingEnvironment); // It is not necessary to add the hosting environment because it is already there.

        //form settings
        //Limit the number of form entries to 10,000 (Arbitrarily Number - I don't believe we'll exceed this limit)
        //A Question Checkbox Tree create an entry per checkbox/question forms large forms can reach beyond 1024 entries(the default setting)
        services.Configure<FormOptions>(options => options.ValueCountLimit = 10_000);

        //httpcontext accessor
        services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
        // here follow many more services.AddSingleton and AddScoped calls.

[gfoidl]

Can you try it with a "current template based approach"?
Or provide a full self contained sample, that includes also the Program.cs to see how the host is built. Also which type of host do you use? It may be that there's an old host, which doen't do the validation.

I know porting over to a new host is quite a bit of work, but you should take it into account.

[jhudsoncedaron]

The builder looks like this:

        var host = new WebHostBuilder()
            .UseKestrel(options =>
            {
                /* enormous */
                options.AllowSynchronousIO = true;
            })
            .UseContentRoot(Directory.GetCurrentDirectory())
            .ConfigureLogging((logging) =>
            {
                /* several lines here */
#if DEBUG
                logging.AddDebug();
#endif
            })
            .UseIISIntegration()
            .UseIIS() // Enables use of IIS in the case of IIS launch; does not force IIS.
            .ConfigureServices((services) =>
            {
                /* this just adds the configuration (appsettngs.json) to the services */
            })
            .UseStartup<Startup>()
            .UseSetting(WebHostDefaults.ApplicationKey, /* redacted*/ )
            .Build();