DryIoC – inversão de controle e injeção de dependência no .net

Facebooktwittergoogle_plusredditpinterestlinkedinmail

O DryIoC é um dos muitos containers de inversão de controle disponíveis para .net. Ele não está entre os mais conhecidos, como o Autofac e o Unity, mas ele vem sendo bem avaliado e bem falado. Ele é pequeno, leve, muito rápido e completo. Em uma série de comparativos entre os diversos containers de inversão de controle, e testes de performance, ele tem se saído muito bem, briga de igual para igual com os principais containers no quesito recursos disponíveis, mas onde vem se destacando mais, e deixando os concorrentes para trás, é na velocidade, o DryIoC tem se mostrado muito leve e rápido. Por isso, hoje, vamos dar uma olhada nele mais de perto, e ver como fazemos para utilizá-lo.

Vamos criar uma aplicação console, e instalar o pacote do DryIoC usando o NuGet. Nós temos duas opções de pacote, um contendo apenas o assembly, e outro contendo o código-fonte. Faça a instalação do pacote de sua preferência.

Agora vamos criar uma interface chamada ICalculo:

namespace DryIoCDemo
{
    public interface ICalculo
    {
        double Calcular(double a, double b);
    }
}

E vamos criar duas classes que implementam essa interface, sendo uma chamada Soma:

namespace DryIoCDemo
{
    public class Soma : ICalculo
    {
        public double Calcular(double a, double b) => a + b;
    }
}

E uma chamada Subtracao:

namespace DryIoCDemo
{
    public class Subtracao : ICalculo
    {
        public double Calcular(double a, double b) => a - b;
    }
}

Agora vamos criar uma classe chamada Calculadora com o código abaixo:

using System;
using System.Collections.Generic;

namespace DryIoCDemo
{
    public class Calculadora
    {
        IEnumerable<ICalculo> Calculos { get; set; }

        public Calculadora(IEnumerable<ICalculo> calculos)
        {
            this.Calculos = calculos;
        }

        public void EfetuarCalculos(double a, double b)
        {
            foreach (var calculo in Calculos)
            {
                var result = calculo.Calcular(a, b);
                Console.WriteLine($"Resultado: {result}");
            }
        }
    }
}

Criamos uma propriedade Calculos, que é uma lista de ICalculo, e no construtor da classe, estamos atribuindo para nossa propriedade a lista recebida como parâmetro. E o método EfetuarCalculos, recebe dois parâmetros do tipo double, e percorre a lista de Calculos, e exibe o resultado do cáclulo no console do .net.

Agora, vamos alterar a classe Program, e ver como o DryIoC funciona. Primeiro de tudo vamos declarar e criar o container do DryIoC:

Container container = new Container();

Agora vamos registrar nossas classes:

container.Register<ICalculo, Soma>();
container.Register<ICalculo, Subtracao>();
container.Register<Calculadora>(Reuse.Singleton);

Na primeira e segunda linhas, nós registramos a classe Soma e Subtracao, para serem devolvidas pelo container quando solicitarmos a interface ICalculo. O método Register, pode receber dois tipos, o primeiro é a interface, e o segundo deve ser a classe.

Na terceira linha, nós registramos a classe Calculadora, e não registramos nenhuma interface, ou seja, vamos pedir ao container pela própria classe, e além disso, dissemos ao container que queremos que sempre seja devolvida a mesma instância, através do parâmetro Reuse.Singleton. Quando não informamos ao container o parâmetro Reuse, ele usará o padrão, que é Transient, e cria uma nova instância a cada solicitação.

Agora, vamos pedir ao container que nos de uma instância de Calculadora:

Calculadora calculadora = container.Resolve<Calculadora>();

Para pedir ao container uma classe, basta chamarmos Container.Resolve e passar o tipo desejado. E agora vamos usar nossa classe e chamar o método EfetuarCalculo para ver o resultado:

calculadora.EfetuarCalculos(500, 200);

O que será que vai acontecer aqui? Serão impressas duas linhas:

Resultado: 700
Resultado: 300

Mas peraí, como que ele fez a soma e a subtração se em lugar nenhum nós pedimos para o container injetar essas classes em nossa Calculadora? Simples, elas foram injetadas pelo construtor da classe Calculadora, que recebe um IEnumerable<ICalculo>. Um ponto legal o DryIoC, é que quando registramos mais de uma classe que implemente a mesma interface, podemos pedir para o container que nos devolva uma implementação específica, através de parâmetros ou chaves, ou, podemos simplesmente pedir para o container que nos devolva todas as classes que implementem aquela interface, e o container nos devolve um IEnumerable de nossa interface, e foi justamente isso que fizemos no nosso construtor. Então o DryIoC injetou para nós todas as implementações de ICalculo registradas.

Para fazermos isso diretamente, nós usamos o código abaixo:

IEnumerable<ICalculo> calculos = container.Resolve<IEnumerable<ICalculo>>();

Nós usamos o método Resolve, da mesma forma que usamos acima quando pedimos pela Calculadora, a diferença, foi que em ver de pedirmos por um tipo, nós pedimos por um IEnumerable de um tipo. Podemos usar o código abaixo para testar se o código acima funciona:

foreach (var calculo in calculos)
{
    var result = calculo.Calcular(100, 50);
    Console.WriteLine($"Resultado: {result}");
}

E veremos como resultado:

Resultado: 150
Resultado: 50

No final, o código completo de nossa classe Program ficou assim:

using DryIoc;
using System;
using System.Collections.Generic;

namespace DryIoCDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Container container = new Container();
            container.Register<ICalculo, Soma>();
            container.Register<ICalculo, Subtracao>();
            container.Register<Calculadora>(Reuse.Singleton);

            Calculadora calculadora = container.Resolve<Calculadora>();
            calculadora.EfetuarCalculos(500, 200);

            IEnumerable<ICalculo> calculos = container.Resolve<IEnumerable<ICalculo>>();
            foreach (var calculo in calculos)
            {
                var result = calculo.Calcular(100, 50);
                Console.WriteLine($"Resultado: {result}");
            }

            Console.Read();
        }
    }
}

O DryIoC tem muitas semelhanças com o Autofac, que já vimos aqui anteriormente em uma série de posts, mas na minha opinião, a API do Autofac é mais simples e bem documentada, sendo assim mais fácil de utilizar quando você precisa fazer algo mais complexo. Mas para quem precisa de uma performance maior, o DryIoC é uma opção interessante e vale a pena ser avaliado.

O código do nosso exemplo está disponível no GitHub: https://github.com/rdakar/dryioc-primeiros-passos

Para mais informações, visite a página oficial do DryIoC: https://bitbucket.org/dadhi/dryioc

 

Facebooktwittergoogle_plusredditpinterestlinkedinmail

1 thought on “DryIoC – inversão de controle e injeção de dependência no .net

Deixe uma resposta

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