ASP .NET Core - Usando a Injeção de dependência nativa

 Neste artigo eu vou mostrar como utilizar a injeção de dependência nataiva da ASP .NET Core MVC usando o VS Community 2017.

Para acompanhar este artigo você precisa ter instalado o Visual Studio Community 2017 com os seguintes workloads instalados:

A idéia da Injeção de Dependência é que, quando uma classe for criada, ela deve ter suas classes dependentes injetadas ao invés de criar essas classes. Isto proporciona uma situação na qual obtemos um fraco acoplamento e uma alta coesão.

Podemos implementar a injeção de dependência das seguintes maneiras:

A injeção de dependência via Construtor é a abordagem mais utilizada e a ASP .NET Core usa essa abordagem no seu contâiner DI.

Então vamos ao trabalho mostrar como usar a injeção de dependência nativa na ASP .Net Core.

Criando o projeto no VS Community 2017

Abra no VS community 2017 e no menu File clique em New Project;

A seguir selecione o template Visual C# -> .NET Core e marque ASP .NET Core Web Application (.NET Core);

Informe o nome AspnetCore_WebApi e clique no botão OK;

Na próxima janela escolha a versão ASP .NET Core 1.1 e marque o template Web Api sem autenticação e clique no botão OK;

Ao final teremos nosso projeto ASP .NET Core criado.

Criando um exemplo básico de ID

Para mostrar como a injeção de dependência (DI) funciona na ASP .NET Core vamos partir dessa aplicação MVC que acabamos de criar.

Suponha que precisamos modelar uma lista de usuários para a nossa aplicação. Vamos iniciar definindo a classe que representa os usuários.

Crie uma pasta Models no projeto usando o menu Project -> Add New Folder e informe o nome Models.

Clique com o botão direito do mouse na pasta Models e selecione Add ->Class, atribua o nome Usuario à classe e clique em Add.

Substitua o código gerado pelo código abaixo:

using System;
namespace AspnCore_DI.Models
{
    public class Usuario
    {
        public string Nome { get; set; }
        public string Sobrenome { get; set; }
        public DateTime Nascimento { get; set; }
        public string NomeUsuario { get; set; }
    }
}

Vamos agora incluir um implementar o padrão repositório, e, a abordagem clássica para fazer isso, é criar uma interface contendo os métodos que desejamos expor e a seguir implementar essa interface na classe repositório.

O motivo para usar o padrão repositório é que assim podemos referenciar a interface em nosso controlador ASP .NET e não a classe concreta.(tendo assim um acoplamento fraco)

Clique com o botão direito do mouse na pasta Models e selecione Add -> New Item e selecione o template Interface e informe o nome IUsuarioRepositorio e clique no botão Add;

A seguir defina o código abaixo nesta interface:

using System.Collections.Generic;
namespace AspnCore_DI.Models
{
    public interface IUsuarioRepositorio
    {
        List<Usuario> GetTodosUsuarios();
    }
}

Nesta interface estamos definindo um método para retornar todos os usuários. Vamos agora implementar essa interface.

Clique com o botão direito do mouse na pasta Models e selecione Add -> Class e informe o nome UsuarioRepositorio e clique no botão Add;

Inclua o código a seguir nesta classe:

using System;
using System.Collections.Generic;

namespace AspnCore_DI.Models
{
    public class UsuarioRepositorio : IUsuarioRepositorio
    {
        public List<Usuario> GetTodosUsuarios()
        {
            return new List<Usuario>
           {
               new Usuario()
               {
                   Nome = "Jose",
                   Sobrenome="Macoratti",
                   Nascimento= new DateTime(1997,02,03),
                   NomeUsuario="macoratti"
               },
               new Usuario()
               {
                   Nome = "Miriam",
                   Sobrenome="Silveira",
                   Nascimento= new DateTime(1999,11,08),
                   NomeUsuario="miriam"
               },
           };
        }
    }
}

No código acima temos a implementação do método GetTodosUsuraios(), definidos na interface IUsuarioRepositorio, onde estamos definindo e retornando dois usuários.

Usando um Controller no projeto

Se você não sabe o que é um Controller então pode ler os seguintes artigos  :

Os Controllers ou Controladores são os componentes que lidam com a interação do usuário, trabalham com o modelo e, finalmente, selecionam uma exibição de renderização que mostra essa interface ao usuário. Por padrão os controladores são colocados na pasta Controllers da solução, e, por padrão ao criar um novo projeto o controlador HomeController é criado nesta pasta.

Vamos então usar o controlador HomeController criado na pasta Controllers.

Abra o arquivo HomeController.cs e substitua o código gerado pelo código abaixo:

using AspnCore_DI.Models;
using Microsoft.AspNetCore.Mvc;
namespace AspnCore_DI.Controllers
{
    public class HomeController : Controller
    {
        private readonly IUsuarioRepositorio _usuarioRepo;
        public HomeController(IUsuarioRepositorio usuarioRepo)
        {
            _usuarioRepo = usuarioRepo;
        }
        [HttpGet]
        public IActionResult Index()
        {
            return View(_usuarioRepo.GetTodosUsuarios());
        }
    }
}

Neste código temos uma instância private readonly de nossa interface IUsuarioRepositorio, e, o construtor toma uma instância de IUsuarioRepositorio e define nossa instância particular para a instância passada.  Esta é a injeção de dependência via construtor em ação.

Agora precisamos configurar o projeto ASP .Net Core para fazer a injeção, e, para isso, vamos usar o arquivo Startup.cs, que configura o ambiente no qual nosso aplicativo será executado.

O arquivo Startup.cs coloca os serviços na camada de serviços do ASP.NET Core, que é o que permite a injeção de dependência.

Abra o arquivo Startup.cs e inclua o código destacado em azul :

using AspnetCore_DI.Models;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
...
public class Startup
{
       ...
     // This method gets called by the runtime. Use this method to add services to the container.
     public void ConfigureServices(IServiceCollection services)
     {
            // Add framework services.
            services.AddMvc();
            services.AddTransient<IUsuarioRepositorio, UsuarioRepositorio>();
     }
   ...
}

O método ConfigureServices() é responsável por definir os serviços que a aplicação vai usar, incluindo recursos da plataforma como ASP .NET Core MVC e Entity Framework.

Na implementação da Injeção de dependência do ASP.NET Core, vemos o conceito de lifetimes ou "tempo de vidas". Um lifetime ou tempo de vida especifica quando um objeto DI-injetado é criado ou recriado. Existem três possibilidades:

  1. - Transient : Criado a cada vez que são solicitados.
  2. - Scoped: Criado uma vez por solicitação.
  3. - Singleton: Criado na primeira vez que são solicitados. Cada solicitação subseqüente usa a instância que foi criada na primeira vez.

O parâmetro IServiceCollection permite configurar diferentes tipos de serviços, seja por criação de objeto ou correspondência a uma interface específica, e suporta os lifetimes mencionados.

No nosso exemplo usamos o lifetime Transient e informando que quando tivermos uma referência a uma instância da interface queremos que seja injetado a instância da classe concreta.

Alterando a View do projeto para exibir o resultado

Vamos agora alterar a view Index.cshtml que já esta criada na pasta Views/Home e que será executada por padrão. (isto esta definido no arquivo Startup.cs no roteamento padrão)

Abra o arquivo Index.cshtml e substitua o código existente pelo código abaixo:

@model IEnumerable<AspnCore_DI.Models.Usuario>
@{
    ViewBag.Title = "Index";
}
<h2>Usuários</h2>
<table border="1" style="width:100%" >
    <tr>
        <th>Nome</th>
        <th>Sobrenome</th>
        <th>Nascimento</th>
        <th>Login</th>
        <th></th>
    </tr>
    @foreach (var item in Model)
    {
        <tr>
            <td>@Html.DisplayFor(modelItem => item.Nome)</td>
            <td>@Html.DisplayFor(modelItem => item.Sobrenome)</td>
            <td>@Html.DisplayFor(modelItem => item.Nascimento)</td>
            <td>@Html.DisplayFor(modelItem => item.NomeUsuario)</td>
        </tr>
    }
</table>

Agora podemos testar. Pressione Ctrl+F5 para rodar a aplicação.

O Visual Studio vai iniciar o navegador e navegar para http://localhost:porta   (onde: porta é um valor escolhido aleatoriamente) exibindo o seguinte resultado:

Observe que, uma vez que adicionamos a interface IUsuarioRepositorio à camada de Serviços, a ASP.NET Core injetou-o automaticamente em nossa classe HomeController.

Isso é a injeção de dependência nativa da ASP .NET Core em ação.

Simples assim...

Dessa forma vimos como é simples e fácil usar o recurso da Injeção da dependência usando a ASP .NET Core.

Mas a hora vem, e agora é, em que os verdadeiros adoradores adorarão o Pai em espírito e em verdade; porque o Pai procura a tais que assim o adorem.
Deus é Espírito, e importa que os que o adoram o adorem em espírito e em verdade.

João 4:23,24

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:


José Carlos Macoratti