Come risolvere l'istanza all'interno di ConfigureServices in ASP.NET Core

È possibile risolvere un'istanza di IOptions<AppSettings>dal ConfigureServicesmetodo in Startup? Normalmente è possibile utilizzare IServiceProviderper inizializzare le istanze, ma in questa fase non è disponibile quando si registrano i servizi.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<AppSettings>(
        configuration.GetConfigurationSection(nameof(AppSettings)));

    // How can I resolve IOptions<AppSettings> here?
}

Puoi creare un fornitore di servizi utilizzando il BuildServiceProvider()metodo su IServiceCollection:

public void ConfigureService(IServiceCollection services)
{
    // Configure the services
    services.AddTransient<IFooService, FooServiceImpl>();
    services.Configure<AppSettings>(configuration.GetSection(nameof(AppSettings)));

    // Build an intermediate service provider
    var sp = services.BuildServiceProvider();

    // Resolve the services from the service provider
    var fooService = sp.GetService<IFooService>();
    var options = sp.GetService<IOptions<AppSettings>>();
}

Hai bisogno del Microsoft.Extensions.DependencyInjectionpacchetto per questo.

Nel caso in cui devi solo associare alcune opzioni ConfigureServices, puoi anche utilizzare il Bindmetodo:

var appSettings = new AppSettings();
configuration.GetSection(nameof(AppSettings)).Bind(appSettings);

Questa funzionalità è disponibile tramite il Microsoft.Extensions.Configuration.Binderpacchetto.

Il modo migliore per creare un'istanza delle classi che dipendono da altri servizi consiste nell'usare l' overload di Add XXX che fornisce IServiceProvider . In questo modo non è necessario creare un'istanza di un fornitore di servizi intermedio.

Gli esempi seguenti mostrano come utilizzare questo overload nei metodi AddSingleton / AddTransient .

services.AddSingleton(serviceProvider =>
{
    var options = serviceProvider.GetService<IOptions<AppSettings>>();
    var foo = new Foo(options);
    return foo ;
});


services.AddTransient(serviceProvider =>
{
    var options = serviceProvider.GetService<IOptions<AppSettings>>();
    var bar = new Bar(options);
    return bar;
});

Il modo più semplice e corretto per ottenere ciò, in tutte le versioni di ASP.NET Core , è implementare l' IConfigureOptions<TOptions>interfaccia. Sebbene questo sia in circolazione da .NET Core 1.0, sembra che poche persone sappiano come fa le cose Just Work ™.

Ad esempio, si desidera aggiungere un validatore di modelli personalizzato che abbia una dipendenza da uno degli altri servizi dell'applicazione. Inizialmente sembra impossibile: non c'è modo di risolvere IMyServiceDependencyperché non hai accesso a un IServiceProvider:

public class MyModelValidatorProvider : IModelValidatorProvider
{
    public MyModelValidatorProvider(IMyServiceDependency dependency)
    {
        ...
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers(options =>
    {
        options.ModelValidatorProviders.Add(new MyModelValidatorProvider(??????));
    });
}

Ma la "magia" di IConfigureOptions<TOptions>rende tutto così facile:

public class MyMvcOptions : IConfigureOptions<MvcOptions>
{
    private IMyServiceDependency _dependency;

    public MyMvcOptions(IMyServiceDependency dependency)
        => _dependency = dependency;

    public void Configure(MvcOptions options)
    {
        options.ModelValidatorProviders.Add(new MyModelValidatorProvider(_dependency));
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // or scoped, or transient
    services.AddSingleton<IConfigureOptions<MvcOptions>, MyMvcOptions>();
    services.AddControllers();
}

In sostanza, qualsiasi configurazione che avresti fatto nei Add***(***Options)delegati in ConfigureServicesviene ora spostata nel metodo IConfigureOptions<TOptions>della tua classe Configure. Quindi registri le opzioni nello stesso modo in cui registri qualsiasi altro servizio e via!

Per maggiori dettagli, oltre che per informazioni su come funziona dietro le quinte, vi rimando al sempre eccellente Andrew Locke .

Cerchi qualcosa come seguire? Puoi dare un'occhiata ai miei commenti nel codice:

// this call would new-up `AppSettings` type
services.Configure<AppSettings>(appSettings =>
{
    // bind the newed-up type with the data from the configuration section
    ConfigurationBinder.Bind(appSettings, Configuration.GetConfigurationSection(nameof(AppSettings)));

    // modify these settings if you want to
});

// your updated app settings should be available through DI now

Vuoi aiutare gli altri che hanno lo stesso aspetto ma anche quando usano Autofac.

Se vuoi ottenere ILifetimeScope (cioè il contenitore dell'ambito corrente) devi chiamare il app.ApplicationServices.GetAutofacRoot()metodo in Configure(IApplicationBuilder app)questo restituirà l'istanza di ILifetimeScope che puoi usare per risolvere i servizi

public void Configure(IApplicationBuilder app)
    {
        //app middleware registrations 
        //...
        //

        ILifetimeScope autofacRoot = app.ApplicationServices.GetAutofacRoot();
        var repository = autofacRoot.Resolve<IRepository>();
    }