Artigos .NET Introdução à Injeção de Dependência no ASP.NET MVC

A cultura de desenvolvimento com ASP.NET MVC

É notável a rápida aceitação e popularização do ASP.NET MVC entre a comunidade .NET, não só pelas suas óbvias vantagens comparadas com o Web Forms (modelo mais simples, controle total sobre a marcação e separação clara de responsabilidades), como também pela grande sensação passada pelo framework de que estamos “desenvolvendo da forma correta”.

Desenvolver de forma correta é algo muito relativo, por exemplo, considerando que um desenvolvedor irá utilizar o ASP.NET MVC como plataforma para criar uma aplicação, poderíamos dizer que ele está fazendo tudo certo caso siga as regras abaixo:

  • Inserir lógica de negócio/domínio e camada de acesso a dados no Modelo;
  • Criar a interface do usuário, não vinculando regras de negócio, através das Visões;
  • Efetuar o tratamento de requisições buscando objetos no modelo e selecionando Visões através do Controle.

As regras acima são suficientes para assegurar que o padrão MVC está sendo seguido, mas será que elas respondem a pergunta: “Estou desenvolvendo da forma correta?”.

Para responder a pergunta acima, é necessário entender se existem algumas necessidades para a aplicação, entre elas podemos citar:

  • Facilidade de manutenção;
  • Extensível de forma simples (sem traumas).

Os dois requisitos citados acima podem mudar drasticamente o modo como a aplicação deverá ser desenvolvida, o padrão MVC não garante que o objetivo será cumprido. Para entender melhor vejamos o exemplo abaixo:

Listagem 1: Exmplo de modelo e controlador


namespace Models
{
    public class Pessoa
    {
        public int PessoaID { get; set; }
        public string Nome { get; set; }
        public DateTime DataNascimento { get; set; }
    }
}

namespace Controllers
{
    public class PessoaController : Controller
    {
        readonly Pessoa _pessoa;

        public PessoaController(Pessoa pessoa)
        {
            _pessoa = pessoa;
        }

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

    }
}

Existe um grande problema no código mostrado, note que o construtor do controle está instanciando um objeto do tipo Pessoa. Isso cria um forte acoplamento entre as duas classes, dificultando o processo de manutenção, isso porque caso a classe Pessoa precise ser substituída, teremos que alterar todos os controles que fazem referência a essa classe.

Para resolver esse problema temos um padrão de desenvolvimento chamado de Inversão de Controle, que basicamente permite retirarmos a responsabilidade dos controles de instanciar objetos do modelo, centralizando essa ação em um “container” que irá injetar as dependências quando necessário.

Resumindo, a responsabilidade de instanciar objetos é retirada do desenvolvedor e delegada para um componente.

É aí que entra o Ninject, um container para injeção de dependência que pode ser configurado facilmente no ASP.NET MVC.

Ninject

Vamos começar a fazer algumas alterações no código para poder utilizar o Ninject. A primeira coisa que vamos fazer é criar uma Interface IPessoa que a classe Pessoa irá implementar como mostrado abaixo:

Listagem 2: Interface IPessoa implementada pela classe Pessoa


    public interface IPessoa
    {
        int PessoaID { get; set; }
        string Nome { get; set; }
        DateTime DataNascimento { get; set; }
    }

    public class Pessoa : IPessoa
    {
        public int PessoaID { get; set; }
        public string Nome { get; set; }
        public DateTime DataNascimento { get; set; }
    }

Agora podemos fazer o desacoplamento da classe Pessoa no nosso controle fazendo o mesmo trabalhar com a interface:

Listagem 3: Desacomplando o controlador da classe Pessoa


    public class PessoaController : Controller
    {
        readonly IPessoa _pessoa;

        public PessoaController(IPessoa pessoa)
        {
            _pessoa = pessoa; 
        }

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

    }

O próximo passo é configurar o Ninject para injetar as dependências em nosso controle.

O Ninject contém um pacote NuGet que já adiciona todas as referências necessárias em nosso projeto, para utilizá-lo execute o comando abaixo no Package Manager Console:

Listagem 4: Baixando o Ninject para o projeto

install-package Ninject

O ASPNET MVC 4 trabalha com uma forma muito simples para adicionarmos injeção de dependência na aplicação, basta criarmos uma classe que implementa a interface System.Web.Mvc.IdependencyResolver e registra-la, nenhuma configuração adicional é necessária.

Crie um arquivo chamado IocConfig na pasta App_Start e adicione as referências abaixo:

Listagem 5: Referências necessárias para uso do Ninject


using Ninject;
using Ninject.Syntax;

Crie a classe abaixo no mesmo arquivo sem apagar a classe IocConfig:

Listagem 6: Classe NinjectDependencyResolver


    public class NinjectDependencyResolver : IDependencyResolver 
    {
        private readonly IResolutionRoot _resolutionRoot;

        public NinjectDependencyResolver(IResolutionRoot kernel) 
        {
            _resolutionRoot = kernel;
        }

        public object GetService(Type serviceType)
        {
            return _resolutionRoot.TryGet(serviceType);
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _resolutionRoot.GetAll(serviceType);
        }
    }

Agora temos que configurar os tipos que o Ninject irá resolver e registrá-lo no ASP.NET, para isso vamos criar o seguinte método na classe IocConfig:

Listagem 7: Método ConfigurarDependencias


        public static void ConfigurarDependencias()
        {
            //Cria o Container 
            IKernel kernel = new StandardKernel();

            //Instrução para mapear a interface IPessoa para a classe concreta Pessoa
            kernel.Bind<IPessoa>().To<Pessoa>();

            //Registra o container no ASP.NET
            DependencyResolver.SetResolver(new NinjectDependencyResolver(kernel));
        }

O método acima cria e registra o Ninject, é importante notar a linha onde é configurado o mapeamento da interface para a classe que será utilizada para injetar a dependência, nesse local pode ser configurado todos os tipos necessários que o Ninject terá que manipular no projeto.

Para terminar basta chamar o método no arquivo Global.asax da seguinte forma:

Listagem 8: Método Aplication_Start


        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
		
            IocConfig.ConfigurarDependencias();            
        }

Agora basta executar a aplicação, coloque um breakpoint no construtor da classe PessoaController e você verá que o Ninject inseriu um objeto do tipo Pessoa no parâmetro do construtor como mostrado abaixo:

Depurando a aplicação

Figura 1: Depurando a aplicação

Podemos observar que com o mínimo de esforço tornamos nossa aplicação facilmente alterável, centralizando a construção de instâncias, permitindo futuras modificações sem a necessidade de reestruturações complexas.