7 tipos de inyección de dependencias ASP.NET aplicación principal

objetos marco muchos núcleo ASP.NET Core se proporcionan a modo de inyección dependiente, tal como el objeto de inicio para inicializar la aplicación, middleware, objetos, y la aplicación ASP.NET Core MVC View Controller objeto y otros objetos, por lo que podemos definirlos cuando se inyecta en forma de servicio al consumidor ya registrado. A continuación se presenta un breve panorama de la inyección de servicios varios. Este artículo extracto de "ASP.NET Core 3 Marco secreto", el 5% de descuento para el libro, así como los dos últimos días , estén interesados pueden escanear el código de dos dimensiones, o el derecho de aquí a la compra del grupo. .

En primer lugar, el tipo de inicio de la inyección de constructor

objetos de dos núcleos de contexto HostBuilderContext configuración (configurado representado IConfiguration objetos que representan el entorno de acogida IHostEnvironment objetos) se pueden inyectar directamente en el constructor de inicio para el consumo. Debido a entorno de aplicaciones de alojamiento ASP.NET Core representado por las interfaces IWebHostEnvironment, interfaces de interfaz IHostEnvironment IWebHostEnvironment está encendido, también es posible mediante la inyección de IWebHostEnvironment obtiene la información del entorno relacionada con el objeto modo de soporte actual.

Podemos a través de un ejemplo sencillo para la inyección de validación para el constructor de inicio. El siguiente fragmento de código que llamamos IWebHostBuilder interfaz de inicio <TStartup> método de tipo personalizado registrado cuando inicio. Al definir Tipo de inicio, inyectamos los tres objetos en su constructor, aserción de depuración no proporcionan sólo demostró los tres objeto no es NULL, también mostró que el uso de interfaces y conectores IWebHostEnvironment IHostEnvironment que eran, de hecho, una y la misma instancia.

clase Programa 
{ 
    estática  vacío Principal () 
    { 
        Host.CreateDefaultBuilder () ConfigureWebHostDefaults (constructor. => builder.UseStartup <inicio> ()) 
        .build () 
        .Llevar (); 
    } 
} 

Pública  clase de inicio 
{ 
    pública puesta en marcha ( configuración IConfiguration, IHostEnvironment hostingEnvironment, IWebHostEnvironment webHostEnvironment ) 
    { 
        Debug.Assert (configuración =! Nulo ); 
        Debug.Assert (hostingEnvironment ! = Nula );
        Debug.Assert (webHostEnvironment =! Nulo ); 
        Debug.Assert (ReferenceEquals (hostingEnvironment, webHostEnvironment)); 
    } 
    Pública  vacío Configurar (IApplicationBuilder aplicación) {} 
}

En segundo lugar, el proceso de inyección Tipo de inicio Configurar

servicios dependientes también pueden ser inyectados directamente en el método de Configurar para el registro de middleware. Si la inyección de constructor de inyección también puede tener una opción de servicio, a continuación, para el método de Configurar, el servicio de registro por cualquier medio que se puede inyectar, incluyendo llamando IHostBuilder, IWebHostBuilder y puesta en marcha de su método ConfigureServices servicios de registro, incluyendo marco de auto-registro de todos los servicios.

El siguiente fragmento de código de código, y que llamamos respectivamente método IWebHostBuilder inicio ConfigureServices de interfaces de registro y de servicios para las interfaces IFoo Ibar, dos servicio Configurar método de inyección directa de Inicio. Además, el método requiere Configurar un objeto proporcionar un IApplicationBuilder middleware utilizado como un argumento registrado, pero no hizo ningún tipo de restricciones sobre la ubicación aparecen los parámetros.

clase Programa 
{ 
    estática  vacío Principal () 
    { 
        Host.CreateDefaultBuilder (). ConfigureWebHostDefaults (constructor => constructor 
            .UseStartup <inicio> () 
            .ConfigureServices (SVC => svcs.AddSingleton <IFoo, Foo> ())) 
        .build () 
        .Correr(); 
    } 
} 

Pública  clase de inicio 
{ 
    públicos  vacíos ConfigureServices (servicios IServiceCollection) => services.AddSingleton <IBar, la barra> ();
    pública  vacío Configurar (IApplicationBuilder aplicación,Foo IFoo, IBar bar ) 
    { 
        Debug.Assert (foo =! Nulo ); 
        Debug.Assert (barra =! Nulo ); 
    } 
}

Tres, de tipo inyección de constructor en el middleware

La mayoría de los objetos importantes ASP.NET Core canalización de procesamiento de solicitud de middleware se utiliza para manejar efectivamente la solicitud. Debido a que ASP.NET Core middleware en la creación de objetos y construyen toda la utilización de tuberías de proceso de peticiones, todos los servicios que ya están registrados, por lo que cualquiera de los servicios registrados pueden inyectarse en el constructor de tipos de middleware. Fragmento de código se muestra a continuación refleja el tipo de middleware para el constructor de la inyección.

clase Programa 
{ 
    estática  vacío Principal () 
    { 
        Host.CreateDefaultBuilder (). ConfigureWebHostDefaults (constructor => constructor 
            .ConfigureServices (SVC => SVCS 
                .AddSingleton <FoobarMiddleware> () 
                .AddSingleton <IFoo, Foo> () 
                .AddSingleton <IBar, Bar > ()) 
            .configure (app => app.UseMiddleware <FoobarMiddleware> ())) 
        .build () 
        .Llevar (); 
    } 
} 

Pública  de claseFoobarMiddleware: IMiddleware 
{ 
    público FoobarMiddleware ( foo IFoo, IBar bar ) 
    { 
        Debug.Assert (foo =! Nula ;) 
        Debug.Assert (barra =! Nulo ); 
    } 

    Pública de tareas invokeAsync (HttpContext contexto, RequestDelegate siguiente) 
    { 
        Debug.Assert (al lado =! Nulo );
        volver Task.CompletedTask; 
    } 
}

En cuarto lugar, el intermedio de tipo de inyección método Invoke / invokeAsync

Si el tipo de middleware se define basa en la forma acordada, el servicio también se puede registrar directamente inyectado método o métodos para procesar una solicitud real de invokeAsync Invoke. Además, un método llamado invokeAsync más de acuerdo con el modo de programación TAP (basado en tareas modelo asincrónico), la razón para retener el nombre del método Invoke, principalmente con fines de compatibilidad de versión. Fragmento de código se muestra a continuación muestra un servicio para el método de implantación invokeAsync.

clase Programa 
{ 
    estática  vacío Principal () 
    { 
        Host.CreateDefaultBuilder (). ConfigureWebHostDefaults (constructor => constructor 
            .ConfigureServices (SVC => SVCS 
                .AddSingleton <IFoo, Foo> () 
                .AddSingleton <IBar, la barra> ()) 
            .configure ( aplicación => app.UseMiddleware <FoobarMiddleware> ())) 
        .build () 
        .Llevar (); 
    } 
} 

Pública  clase FoobarMiddleware 
{ 
    privado  de sólo lectura _next RequestDelegate;

    pública FoobarMiddleware (RequestDelegate siguiente) => = _next siguiente;
    pública de tareas invokeAsync (HttpContext contexto, IFoo foo, IBar bar ) 
    { 
        Debug.Assert (contexto =! nulo ); 
        Debug.Assert (foo =! Nulo ); 
        Debug.Assert (barra =! Nulo );
        volver _next (contexto); 
    } 
}

Aunque la definición acordada de tipos de middleware y el tipo de inicio usa un método de inyección de servicio similar, todos los métodos de inyección de apoyo constructor y de inyección, pero hay algunas diferencias entre ellos. Middleware constructores de tipos, métodos de configurar el tipo de inicio y middleware tipo de método invokeAsync Invoke o métodos que tienen un parámetro requerido, que son de tipo RequestDelegate, IApplicationBuilder la HttpContext y, para esta posición en toda la lista de parámetros, el frente tampoco ninguna restricción, que sólo requiere que la corriente parámetro de contexto solicitud debe HttpContext método que el primer parámetro. De acuerdo con la convención anterior, esto se define como sigue FoobarMiddleware tipo de middleware no es legal, pero el tipo Starup definición es válida. Para esto, creo que este límite puede ser abierto, por lo que no sólo la definición de tipo de middleware es más flexible, pero también para asegurar la consistencia método de inyección.

público  de clase FoobarMiddleware 
{ 
    público FoobarMiddleware (RequestDelegate siguiente);
    pública de tareas invokeAsync (foo IFoo, IBar bar, HttpContext contexto); 
} 

Pública  clase de inicio 
{ 
    público  vacío Configurar (IFoo foo, IBar bar, IApplicationBuilder aplicación); 
}

Para la inyección diferencia esencial existe un middleware, y la inyección de constructor basado en la forma prescrita. Debido a que el middleware está registrada como un Singleton objeto, por lo que no debemos ser inyectado en su constructor Scoped servicios. servicio de middleware Scoped sólo puede tipo de proceso de inyección invokeAsync , como son los servicios dependientes de una gama de servicios proporcionados en la solicitud actual, es posible asegurar Scoped ser liberado después de los extremos de procesamiento de solicitud de servicio actual.

V. tipo de inyección constructor Controller

En una aplicación ASP.NET Core MVC, podemos constructor manera inyección inyecte servicios definidos en el controlador. En el fragmento de código se muestra a continuación, vamos a servicio IFoobar inyectado en el HomeController constructor.

clase Programa 
{ 
    estática  vacío Principal () 
    { 
        Host.CreateDefaultBuilder (). ConfigureWebHostDefaults (constructor => constructor 
            .ConfigureServices (SVC => SVCS 
                .AddSingleton <IFoobar, Foobar> () 
                .AddSingleton <IBar, la barra> () 
                .AddControllersWithViews () ) 
            .configure (app => aplicación 
                .UseRouting () 
                .UseEndpoints (puntos finales => endpoints.MapControllers ()))) 
        .build () 
        .Llevar (); 
    } 
}

 Pública  clase HomeController: Controller 
{ 
    público HomeController ( IFoobar foobar ) => Debug.Assert (! Foobar = nula ); 

}

En sexto lugar, en el método de inyección de Controlador de Acción de

Por medio de modelo ASP.NET Core MVC basado en parámetro mecanismo de unión para la unión, podemos registrar un servicio unido a la diana parámetro métodos de acción, con el fin de realizar el método de inyección para la dependencia de Acción. Cuando se utiliza este tipo de método de inyección, necesitamos marca de la siguiente manera en los parámetros de inyección FromServicesAttribute características, para determinar el parámetro de fuente de unión es un servicio registrada.

clase Programa 
{ 
    estática  vacío Principal () 
    { 
        Host.CreateDefaultBuilder (). ConfigureWebHostDefaults (constructor => constructor 
            .ConfigureServices (SVC => SVCS 
                .AddSingleton <IFoobar, Foobar> () 
                .AddControllersWithViews ()) 
            .configure (app => aplicación 
                . UseRouting () 
                .UseEndpoints (puntos finales => endpoints.MapControllers ()))) 
        .build () 
        .Llevar (); 
    } 
} 

Pública  de claseHomeController: Controller 
{ 
    [HttpGet ( " / " )]
     pública  vacío índice ( [FromServices] IFoobar foobar ) 
    { 
        Debug.Assert (foobar ! = Nula ); 
    } 
}

Siete inyecta en la vista

En aplicación ASP.NET MVC Core, también podemos ahora registrado en el servicio de Vista. Supongamos que definimos el siguiente programa sencillo MVC, y define un HomeController sencilla.

clase Programa 
{ 
    estática  vacío Principal () 
    { 
        Host.CreateDefaultBuilder (). ConfigureWebHostDefaults (constructor => constructor 
            .ConfigureServices (SVC => SVCS 
                .AddSingleton <IFoobar, Foobar> () 
                .AddControllersWithViews ()) 
            .configure (app => aplicación 
                . UseRouting () 
                .UseEndpoints (puntos finales => endpoints.MapControllers ()))) 
        .build () 
        .Llevar (); 
    } 
} 

Pública  de claseHomeController: Controller 
{ 
        [HttpGet ( " / " )]
         pública Índice IActionResult () => Ver (); 
}

Antes de definir una ruta de encaminamiento a la raíz ( "/") Método del Índice de Acción es HomeController, el método presentado en la vista por defecto Ver invocación de método, la prestación de servicios inyecta IFoo a la vista de forma ViewBag. Fragmento de código se muestra a continuación que este método corresponde a la definición de la acción de la vista (/Views/Home/Index.cshtml), se inyectan a través de la instrucción @Inject servicio IFoobar y el nombre del atributo a Foobar, esto significa que el actual objeto View foobar propiedad para añadir un servicio de inyección de referencia.

@Inject IFoobar Foobar 
@ 
{ 
    Debug.Assert (Foobar ! = nula ); 
}