Cómo resolver una instancia dentro de ConfigureServices en ASP.NET Core

¿Es posible resolver una instancia de IOptions<AppSettings>desde el ConfigureServicesmétodo en Inicio? Normalmente, puede usar IServiceProviderpara inicializar instancias, pero no lo tiene en esta etapa cuando está registrando servicios.

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

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

Puede crear un proveedor de servicios utilizando el BuildServiceProvider()método en 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>>();
}

Necesita el Microsoft.Extensions.DependencyInjectionpaquete para esto.

En el caso de que solo necesite vincular algunas opciones ConfigureServices, también puede usar el Bindmétodo:

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

Esta funcionalidad está disponible a través del Microsoft.Extensions.Configuration.Binderpaquete.

La mejor manera de crear instancias de clases que dependen de otros servicios es utilizar la sobrecarga Add XXX que le proporciona IServiceProvider . De esta forma, no es necesario crear una instancia de un proveedor de servicios intermedio.

Los siguientes ejemplos muestran cómo puede utilizar esta sobrecarga en los métodos 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;
});

La forma más sencilla y correcta de lograr esto, en todas las versiones de ASP.NET Core , es implementar la IConfigureOptions<TOptions>interfaz. Si bien esto ha existido desde .NET Core 1.0, parece que pocas personas saben cómo hace que las cosas funcionen simplemente .

Como ejemplo, desea agregar un validador de modelo personalizado que dependa de uno de los otros servicios de su aplicación. Inicialmente parece imposible; no hay forma de resolverlo IMyServiceDependencyporque no tiene acceso a un IServiceProvider:

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

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

Pero la "magia" de lo IConfigureOptions<TOptions>hace tan fácil:

public class ConfigureMvcOptions : 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)
{
    services.AddControllers();

    ...

    // or scoped, or transient, as necessary for your service
    services.AddSingleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptions>();
}

Esencialmente, cualquier configuración que hubiera hecho en los Add***(***Options)delegados ConfigureServicesahora se mueve al método de su IConfigureOptions<TOptions>clase Configure. Luego registra las opciones de la misma manera que registraría cualquier otro servicio, ¡y listo!

Para obtener más detalles, así como información sobre cómo funciona esto detrás de escena, lo remito al siempre excelente Andrew Lock .

¿Estás buscando algo como seguir? Puedes echar un vistazo a mis comentarios en el código:

// 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

Quiere ayudar a otras personas que tienen el mismo aspecto pero que también usan Autofac.

Si desea obtener ILifetimeScope (es decir, un contenedor del alcance actual), debe llamar al app.ApplicationServices.GetAutofacRoot()método, Configure(IApplicationBuilder app)esto devolverá la instancia de ILifetimeScope que puede usar para resolver los servicios

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

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