Autofac – Injetando dependências através de construtores

Facebooktwittergoogle_plusredditpinterestlinkedinmail

Anteriormente, aqui em nosso blog, começamos a ver como utilizar o Autofac em um projeto .net no post Autofac – inversão de controle e injeção de dependência no .net. Hoje vamos ver como fazer para que o Autofac injete as instâncias das classes que precisamos através de construtores. Dessa forma não precisamos mais pedir os objetos usando o “Resolve”.

Vamos aproveitar o exemplo que criamos no post anterior, e criar uma nova interface com o código abaixo:

namespace AutofacDemoWin
{
    public interface ILinguagemProgramacao
    {
        string Nome { get; }
        double Versao { get; }
    }
}

E também criar uma nova classe, implementando essa interface:

namespace AutofacDemoWin
{
    public class LinguagemCSharp : ILinguagemProgramacao
    {
        public string Nome
        {
            get
            {
                return "C#";
            }
        }

        public double Versao
        {
            get
            {
                return 4.6;
            }
        }
    }
}

Agora, vamos alterar a nossa classe DesenvolvedorNinja, e deixá-la da seguinte forma:

namespace AutofacDemoWin
{
    public class DesenvolvedorNinja : IDesenvolvedor
    {
        private ILinguagemProgramacao _linguagemProgramacao;

        public DesenvolvedorNinja(ILinguagemProgramacao linguagemProgramacao)
        {
            this._linguagemProgramacao = linguagemProgramacao;
        }

        public string GetLinguagemProgramacao()
        {
            return _linguagemProgramacao.Nome;
        }
    }
}

Feito isso, agora precisamos alterar o nosso form, para registrar a nova interface, sendo assim, nosso evento Load ficará da seguinte forma:

private void FormAutofacDemoWin_Load(object sender, EventArgs e)
{
	var builder = new ContainerBuilder();
	builder.RegisterType<DesenvolvedorNinja>().As<IDesenvolvedor>().InstancePerDependency();
	builder.RegisterType<LinguagemCSharp>().As<ILinguagemProgramacao>().InstancePerDependency();
	_container = builder.Build();
}

Dessa forma registramos nossa nova classe e a nova interface, e pronto, não precisamos mexer no código do nosso segundo botão, que permanece dessa forma:

private void buttonObterLinguagemAutofac_Click(object sender, EventArgs e)
{
	IDesenvolvedor desenvolvedor = _container.Resolve<IDesenvolvedor>();
	MessageBox.Show(desenvolvedor.GetLinguagemProgramacao());
}

Porém, do jeito que ficou nossa classe DesenvolvedorNinja, o código do primeiro botão deixou de funcionar, pois agora o construtor da classe exige um parâmetro, então, precisamos alterá-lo para ficar assim:

private void buttonObterLinguagemDefault_Click(object sender, EventArgs e)
{
	IDesenvolvedor desenvolvedor = new DesenvolvedorNinja(new LinguagemCSharp());
	MessageBox.Show(desenvolvedor.GetLinguagemProgramacao());
}

Tivemos que criar um objeto do tipo LinguagemCSharp, e passá-lo como parâmetro para o construtor da classe DesenvolvedorNinja. Ou seja, ao mudarmos nossa classe DesenvolvedorNinja, todo mundo que a criava usando “new”, foi afetado, e precisou ser ajustado, o que não ocorre quando usamos a inversão de controle, pois ela diminui o acoplamento de forma significativa.

Resumindo, usar o Autofac para injetar em nossas classes as dependências que precisamos, através do construtor, é extremamente simples, basta adicionarmos os parâmetros que desejamos em nosso construtor e pronto, o Autofac faz o resto.

Segue abaixo como ficou o código completo do nosso form:

using Autofac;
using System;
using System.Windows.Forms;

namespace AutofacDemoWin
{
    public partial class FormAutofacDemoWin : Form
    {
        private IContainer _container;

        public FormAutofacDemoWin()
        {
            InitializeComponent();
        }

        private void buttonObterLinguagemDefault_Click(object sender, EventArgs e)
        {
            IDesenvolvedor desenvolvedor = new DesenvolvedorNinja(new LinguagemCSharp());
            MessageBox.Show(desenvolvedor.GetLinguagemProgramacao());
        }

        private void FormAutofacDemoWin_Load(object sender, EventArgs e)
        {
            var builder = new ContainerBuilder();
            builder.RegisterType<DesenvolvedorNinja>().As<IDesenvolvedor>().InstancePerDependency();
            builder.RegisterType<LinguagemCSharp>().As<ILinguagemProgramacao>().InstancePerDependency();
            _container = builder.Build();
        }

        private void buttonObterLinguagemAutofac_Click(object sender, EventArgs e)
        {
            IDesenvolvedor desenvolvedor = _container.Resolve<IDesenvolvedor>();
            MessageBox.Show(desenvolvedor.GetLinguagemProgramacao());
        }
    }
}

Em um próximo post, vamos continuar evoluindo nosso exemplo, e mostrar pontos e características mais avançadas do Autofac.

O código-fonte completo do exemplo está disponível no GitHub: https://github.com/desenvolvedorninja/autofac-injecao-via-construtor

Quase 20 anos de experiência no mercado de TI.
Atuação em grandes empresas como Netshoes, Borland, JBS, Bradesco, Hospital das Clínicas, Rede, Prodam, HSPE, Instituto Ayrton Senna, e também em empresas internacionais como Delta Dental, T-Mobile, Pepsi e Mckesson.
Fundador da TecPrime Solutions, administrador da comunidade nopCommerce Brasil, e autor dos sites InvestFacil.net e Desenvolvedores.ninja

Facebooktwittergoogle_plusredditpinterestlinkedinmail

3 thoughts on “Autofac – Injetando dependências através de construtores

  1. O codigo acima e compilado sem nenhum erro, porem ao executarmos esse controller ocorrera um erro, ja que nao temos um construtor sem parametros definido e nenhuma interface sendo injetada na classe. Para resolvermos esse problema vamos utilizar um terceiro elemento para injetar a dependencia do controller, nesse caso utilizaremos o Ninject .

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *