DependencyInjectionRepository

Inyección de dependencia

Ejemplo de muestra utilizando el núcleo de Asp.net

Enlace del vídeo grabado: https://www.youtube.com/watch?v=oVj1IHw8GLU

Descripción general de DI: https://github.com/sandeepmvn/DependencyInjectionRepository/blob/master/OverviewOfDI.txt

ASP.NET Core admite el patrón de diseño de software de inyección de dependencias (DI), que es una técnica para lograr la inversión de control (IoC) entre clases y sus dependencias.

A través del contenedor IoC, podemos lograr

1. Clases poco acopladas
2. Gestión de la vida útil del objeto.
3. Inyecta dependencias a la clase.
4. Fácil de cambiar la implementación.
5. Desarrollo impulsado por pruebas (TDD)

En el núcleo de Asp.net, IoC Container tiene interfaces integradas.

1. IServicioProveedor
2. Colección IService

El siguiente ciclo de vida DI será

1. Registro:-
   1. El contenedor debe saber qué tipo de objeto/dependencia debe crear una instancia.
   2. En el núcleo de Asp.net, los servicios se registran mediante "IServiceCollection".
   3. Estos servicios normalmente se registran en el método "Startup.ConfigureServices" de la aplicación.
2. Resolver:-
   1. Cuando utilizamos el contenedor IoC, no creamos objetos manualmente, Container lo hace por nosotros.
   2. En el núcleo de Asp.net, el marco asume la responsabilidad de crear una instancia de la dependencia con soporte para el contenedor integrado (IServiceProvider).
3. Eliminar: - La vida útil del objeto/dependencia será asumida únicamente por el contenedor IOC

Básicamente existen dos tipos de servicios en ASP.NET Core:

Servicios de marco: servicios que forman parte del marco ASP.NET Core, como IApplicationBuilder, IHostingEnvironment, ILoggerFactory, etc.

Servicios de aplicación: los servicios (tipos o clases personalizados) que usted, como programador, crea para su aplicación.

Inyección de dependencia en el controlador (MVC): -

El controlador Asp.Net Core MVC solicita dependencias explícitamente a través de constructores 1. Inyección de constructor 2. Inyección de método (nivel de acción) 3. Inyección adecuada (no compatible) 4. Inyección de vista

1. Inyección de constructor: - Los servicios se agregan como parámetro del constructor y el tiempo de ejecución resuelve el servicio desde el contenedor de servicios (IServiceCollection-- DiContainer). Los serviciosa generalmente se definen utilizando clases (interfaces) no concretas.

2. Inyección de método: - El uso del atributo [FromService] permite inyectar el servicio directamente en un método de acción sin utilizar la inyección del controlador.

3. Inyección de propiedades Actualmente, el contenedor IOC incorporado (Asp.net core) no admite la inyección de propiedades. Para esto, puede optar por contenedores de servicios integrados (IOC) de terceros.

4. Ver inyección El uso de la directiva [Inject] permite inyectar el servicio directamente en la página de visualización sin utilizar el controlador o la inyección de método.

Vida útil del servicio

El contenedor IoC incorporado admite tres tipos de vida útil:

1. Semifallo:
   1. Los servicios de por vida Singleton (servicio de estado) se crean la primera vez que se solicitan (o cuando se ejecuta ConfigureServices si especifica una instancia allí) y luego cada solicitud posterior utilizará la "misma instancia" durante toda la vida útil de la aplicación.
   2. Core le proporciona métodos de extensión integrados
      1. Agregar() (ServiceLifetime.Singleton)
      2. Agregar Singleton()
2. Transitorio:
   1. Los servicios transitorios de por vida se crean cada vez que se solicitan. Esta vida útil funciona mejor para "servicios sin estado" livianos.
   2. Core le proporciona métodos de extensión integrados
      1. Agregar() con (ServiceLifetime.Transient)
      2. AgregarTransiente()
3. Alcance:
   1. Los servicios de por vida con alcance se crean una vez por solicitud y se compartirán en una sola solicitud.
   2. Core le proporciona métodos de extensión integrados
      1. Agregar() con (ServiceLifetime.Scoped)
      2. Agregar alcance ()
      3. AgregarContextoDB()

Registro del servicio de aplicación simple

En el ejemplo de ejemplo, la interfaz de servicio "IMyDependency" define el método "WriteMessage"

  public interface IMyDependency
  {
      void WriteMessage(string message);
  }

Esta interfaz se implementa mediante un tipo concreto, MyDependency:

  public class MyDependency : IMyDependency
  {
      public void WriteMessage(string message)
      {
          Console.WriteLine($"MyDependency.WriteMessage Message: {message}");
      }
  }

Ahora, registra el servicio "IMyDependency" con el tipo concreto "MyDependency" (en startup.cs)

  public class Startup
  {
      public void ConfigureServices(IServiceCollection services)
      {
          services.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency()));        
      }

  }

Aquí el método Add() de la instancia "IServiceCollection" se utiliza para registrar un servicio con un contenedor IoC. El "ServiceDescriptor" se utiliza para especificar el tipo de servicio y la implementación concreta. Esto registrará nuestro servicio en el contenedor con el valor predeterminado "Singleton".

Ahora, inyectemos servicios con diferentes tiempos de vida.

1. Singleton (Caso de uso: cuando necesitamos crear un servicio estatal):

   servicios.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency(),ServiceLifetime.Singleton));

2. Transitorio (Caso de uso: cuando necesitamos crear un servicio sin estado):

   servicios.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency(),ServiceLifetime.Transient));

3. Con alcance (caso de uso: servicio de base de datos):

   servicios.Add(new ServiceDescriptor(typeof(IMyDependency), new MyDependency(),ServiceLifetime.Scoped));

También podemos inyectar los servicios utilizando métodos de extensión integrados.

1. Semifallo

   servicios.AddSingleton(); o servicios.AddSingleton(typeof(IMyDependency), typeof(MyDependency));

2. Transitorio

   servicios.AddTransisent(); o servicios.AddTransient(typeof(IMyDependency), typeof(MyDependency));

3. Alcance

   servicios.AddScoped(); o servicios.AddScoped(typeof(IMyDependency), typeof(MyDependency));

Ejemplo con inyección de constructor

clase pública HomeController: Controlador {servicio IMyDependency privado de solo lectura;

 public HomeController(IMyDependency service)
{
    _service = service;
}

public IActionResult Index()
{
    _service.WriteMessage("Constructor level injection")
   
    return View();
}

}

Ejemplo con inyección de acción

 public class HomeController : Controller
{
  //Fromservice attribute
  public IActionResult Index([FromService]IMyDependency service)
  {
      service.WriteMessage("Action level injection")
      return View();
  }
}

Ejemplo con inyección de vista

clase pública HomeController: Controlador {

 public IActionResult Index()
{
    return View();
}

}

En índice.cshtml

@{ ViewData["Título"] = "Página de inicio"; }

 //using Inject directive

@inject IMyDependency service

//code block
@{
  service.WriteMessage("View level Injection");
}

Sin inyección, obtenga servicios manualmente usando HttpContext

clase pública HomeController: Controlador {

 public IActionResult Index()
{
    var services = this.HttpContext.RequestServices;
    var dependencyservice = (IMyDependency)services.GetService(typeof(IMyDependency));
    dependencyservice.WriteMessage("without injection, accessing dependent services");
    return View();
}

}