DependencyInjectionRepository

Injeção de Dependência

Exemplo de exemplo usando o núcleo Asp.net

Link do vídeo gravado: https://www.youtube.com/watch?v=oVj1IHw8GLU

Visão geral do DI: https://github.com/sandeepmvn/DependencyInjectionRepository/blob/master/OverviewOfDI.txt

ASP.NET Core oferece suporte ao padrão de design de software de injeção de dependência (DI), que é uma técnica para obter Inversão de Controle (IoC) entre classes e suas dependências.

Através do contêiner IoC, podemos alcançar

1. Classes fracamente acopladas
2. Gerenciando a vida útil do objeto
3. Injeta dependências na classe
4. Fácil de alterar a implementação
5. Desenvolvimento orientado a testes (TDD)

No núcleo do Asp.net, o IoC Container possui interfaces integradas.

1. IServiceProvider
2. IServiceCollection

O seguinte ciclo de vida da DI será

1. Cadastre-se: -
   1. O Container deve saber qual tipo de objeto/dependência deve instanciar.
   2. No núcleo do Asp.net, os serviços são registrados usando "IServiceCollection".
   3. esses serviços normalmente são registrados no método "Startup.ConfigureServices" do aplicativo.
2. Resolver:-
   1. Ao usar o contêiner IoC, não criamos objetos manualmente, o Container faz isso por nós.
   2. No núcleo do Asp.net, o framework assume a responsabilidade de criar uma instância da dependência com suporte de container embutido (IServiceProvider)
3. Dispor: - O tempo de vida do objeto/dependência será cuidado apenas pelo contêiner IOC

Existem basicamente dois tipos de serviços no ASP.NET Core:

Serviços de estrutura: serviços que fazem parte da estrutura ASP.NET Core, como IApplicationBuilder, IHostingEnvironment, ILoggerFactory etc.

Serviços de aplicativos: os serviços (tipos ou classes personalizados) que você, como programador, cria para seu aplicativo.

Injeção de dependência no controlador (MVC): -

O controlador Asp.Net Core MVC solicita dependências explicitamente por meio de construtores 1. Injeção de construtor 2. Injeção de método (nível de ação) 3. Injeção de propriedade (não suportada) 4. Injeção de visualização

1. Injeção de Construtor: - Os serviços são adicionados como um parâmetro de construtor e o tempo de execução resolve o serviço a partir do contêiner de serviço (IServiceCollection-- DiContainer). Servicesa são normalmente definidos usando classes não concretas (interfaces)

2. Injeção de método: - Usar o atributo [FromService] permite injetar serviço diretamente em um método de ação sem usar injeção de controlador

3. Injeção de propriedade Atualmente (núcleo Asp.net), o contêiner IOC integrado não oferece suporte à injeção de propriedade. Para isso, você pode optar por contêineres de serviço integrados (IOC) de terceiros.

4. Ver injeção usando a diretiva [Inject] permite injetar serviço diretamente na página de visualização sem usar controlador ou injeção de método

Vida útil do serviço

O contêiner IoC integrado suporta três tipos de vida útil:

1. Único:
   1. Os serviços de vida útil singleton (serviço de estado) são criados na primeira vez que são solicitados (ou quando ConfigureServices é executado se você especificar uma instância lá) e então cada solicitação subsequente usará a "mesma instância", durante toda a vida útil do aplicativo
   2. Core fornece métodos de extensão integrados
      1. Adicionar() (ServiceLifetime.Singleton)
      2. AdicionarSingleton()
2. Transitório:
   1. Os serviços vitalícios transitórios são criados sempre que são solicitados. Esse tempo de vida funciona melhor para "serviços sem estado" leves.
   2. Core fornece métodos de extensão integrados
      1. Adicionar() com (ServiceLifetime.Transient)
      2. AdicionarTransiente()
3. Escopo:
   1. Os serviços de vida útil com escopo definido são criados uma vez por solicitação e serão compartilhados em uma única solicitação.
   2. Core fornece métodos de extensão integrados
      1. Adicionar() com (ServiceLifetime.Scoped)
      2. Adicionar escopo()
      3. AdicionarDBContext()

Registrando serviço de aplicativo simples

No exemplo de amostra, a interface de serviço "IMyDependency" define o método "WriteMessage"

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

Esta interface é implementada por um tipo concreto, MyDependency:

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

Agora, registra o serviço "IMyDependency" com o tipo concreto "MyDependency" (em startup.cs)

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

  }

Aqui, o método Add() da instância "IServiceCollection" é usado para registrar um serviço com um contêiner IoC. O "ServiceDescriptor" é usado para especificar o tipo de serviço e implementação concreta. Isso registrará nosso serviço no contêiner com padrão como "Singleton"

Agora, vamos injetar serviços com diferentes tempos de vida

1. Singleton (caso de uso: quando precisamos criar serviço de estado):

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

2. Transitório (caso de uso: quando precisamos criar um serviço sem estado):

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

3. Escopo (caso de uso: serviço de banco de dados):

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

Também podemos injetar os serviços usando métodos de extensão integrados

1. Solteiro

   serviços.AddSingleton(); ou serviços.AddSingleton(typeof(IMyDependency), typeof(MyDependency));

2. Transitório

   services.AddTransisent(); ou serviços.AddTransient(typeof(IMyDependency), typeof(MyDependency));

3. Escopo

   services.AddScoped(); ou serviços.AddScoped(typeof(IMyDependency), typeof(MyDependency));

Exemplo com injeção de construtor

classe pública HomeController: Controlador {privado somente leitura IMyDependency _service;

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

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

}

Exemplo com injeção de ação

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

Exemplo com injeção de visualização

classe pública HomeController: Controlador {

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

}

Em Index.cshtml

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

 //using Inject directive

@inject IMyDependency service

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

Sem injeção, obtenha serviços manualmente usando HttpContext

classe 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();
}

}