La interfaz IServiceCollection se utiliza para construir un contenedor de inyección de dependencias. Después de que se compila completamente, se compone a una instancia IServiceProvider que puede usar para resolver servicios. Puede inyectar un IServiceProvider en cualquier clase. Las clases IApplicationBuilder y HttpContext también pueden proporcionar el proveedor de servicios, a través de las propiedades ApplicationServices o RequestServices respectivamente.

IServiceProvider define un método GetService(Type type) para resolver un servicio:

var service = (IFooService)serviceProvider.GetService(typeof(IFooService));

También hay varios métodos de extensión de conveniencia disponible, como serviceProvider.GetService<IFooService>(). (Añádase un uso para Microsoft.Extensions.DependencyInjection).

Resolviendo servicios dentro de la clase startup

Inyectando dependencias

El tiempo de ejecución puede inyectar servicios en el constructor de la clase Startup, tales como IHostingEnvironment, IConfiguration y IServiceProvider. Tenga en cuenta que este proveedor de servicios es una instancia creada por la capa de alojamiento y contiene solo los servicios para iniciar una aplicación.

Los servicios también se pueden inyectar en el método Configure(). Puede agregar un arbitrario cantidad de parámetros después del parámetro IApplicationBuilder. También puede inyectar sus propios servicios que están registrados en el método ConfigureServices() aquí, se resolverán desde el proveedor de servicios aplicación en lugar del proveedor de servicios alojamiento.

public void Configure(IApplicationBuilder app, IFooService fooService)
{
   // ...
}

El método ConfigureServices() sin embargo, no permite servicios de inyección, solo acepta un argumento IServiceCollection. Este es el método en el que se configura el contenedor de inyección de dependencias de la aplicación. Puede utilizar los servicios inyectados el constructor de la startup aquí. Por ejemplo:

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

public IConfiguration Configuration { get; }

public void ConfigureServices(IServiceCollection services)
{
    // Use Configuration here
}

Resolviendo manualmente dependencias

Si desea resolver manualmente los servicios, puede dejar que el tiempo de ejecución inyecte una instancia IServiceProvider en el constructor o usar el ApplicationServices proporcionado por IApplicationBuilder en el método Configure():

public Startup(IServiceProvider serviceProvider)
{
    var hostingEnv = serviceProvider.GetService<IHostingEnvironment>();
}

O

public void Configure(IApplicationBuilder app)
{
    var serviceProvider = app.ApplicationServices;
    var hostingEnv = serviceProvider.GetService<IHostingEnvironment>();
}

Sin embargo, si necesita resolver servicios en el método ConfigureServices(), necesita un enfoque diferente. Puede crear un IServiceProvider intermedio a partir de una instancia IServiceCollection que contenga el servicios que están registrados hasta entonces:

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IFooService, FooService>();

    // Build the intermediate service provider
    var sp = services.BuildServiceProvider();
    var fooService = sp.GetService<IFooService>();
}

Usted necesita el Microsoft.Extensions.DependencyInjection paquete para esto.

Tenga en cuenta:
Generalmente no debe resolver servicios dentro del método ConfigureServices(), ya que este es en realidad el lugar donde está configurando los servicios de la aplicación. A veces solo necesita acceso a alguna instancia IOptions<MyOptions>. Puede lograr esto vinculando los valores de la instancia IConfiguration a una instancia de MyOptions (que es esencialmente lo que el options framework does):

public void ConfigureServices(IServiceCollection services)
{
    var myOptions = new MyOptions();
    Configuration.GetSection("SomeSection").Bind(myOptions);
}

Resolver manualmente los servicios (también conocido como Localizador de servicios) en general es conocido como un anti-patrón. Si bien tiene sus casos de uso (para marcos y/o capas de infraestructura), debe evitarlo tanto como sea posible.