Injeção de dependência (DI) e Inversão de controle (IoC)

Se chegou até aqui, significa que você já entende, ou está começando a entender, a importância de escrever um bom código. Parabéns! isso é maturidade.

Binhara

2 min

Você está no caminho certo!

Se chegou até aqui significa que você já entende, ou está começando a entender, a importância de escrever um bom código. Parabéns! isso é maturidade.

Sem mais enrolação, SHOW ME THE CODE.

O que é injeção de dependência?

Definição:

É uma técnica para obter inversão de controle (IOC) entre classes e suas dependências.
A injeção de dependência no .NET é um cidadão de primeira classe, juntamente com configuration, logging, e o padrão options.

Na prática:

Injeção de dependência é um design pattern utilizado para remover a dependência entre um objeto e outro.

Ou seja, quando instanciamos um objeto em outro objeto, para utilizar os métodos e função dos quais necessitamos, criamos uma dependência — diminuindo a coesão, aumentando o acoplamento — que pode complicar a atualização do sistema futuramente.

Exemplo de um código dependente:


          
            public class Liga
          
          
            {
          
          
              public string NumeroLigar() 
          
          
              {  
          
          
                var tel = new Telefone();
          
          
                return tel.Numero();
          
          
              }
          
          
            }
          
          
            
          
          
            public class Telefone
          
          
            {
          
          
              public string Numero() => "4002-8922";
          
          
            }

Exemplo do mesmo código, mas sem dependência.


          
            public interface ITelefone {
          
          
                public string Numero();
          
          
            }
          
          
            
          
          
            //Criamos uma interface e definimos um contrato.


          
            public class Liga
          
          
            {
          
          
              public ITelefone _telefone { get; set; }
          
          
              public Liga(ITelefone telefone) 
          
          
              {
          
          
                _telefone = telefone;
          
          
              }
          
          
                public string NumeroLigar() => _telefone.Numero();
          
          
            }
          
          
            
          
          
            //Injetamos a referência no construtor e atribuímos o valor a um campo privado.

Dessa forma, eliminamos a dependência que a classe Liga() possuía ao instanciar a classe Telefone(), como no primeiro exemplo.

Mas o que mudou?

Como podemos reparar no segundo exemplo, criamos uma interface ITelefone, que define um contrato public string Numero(); e a única coisa que nossa classe Liga() precisa se preocupar, é em saber da existência contrato.

Dessa forma, a classe Liga() pode utilizar qualquer outra classe que implemente a interface ITelefone.

Nesse exemplo, utilizamos o principio de inversão de controle (IoC), já que a classe Liga() não é mais responsável por instanciar a classe Telefone(), deixando a responsabilidade de definir a classe concreta para um agente externo, como veremos a seguir:


          
            using DI;
          
          
            using System;
          
          
            namespace DI
          
          
            {
          
          
                class Program
          
          
                {
          
          
                    static void Main(string[] args)
          
          
                    {
          
          
                        var liga = new Liga(new Telefone());
          
          
                        var resultado = liga.NumeroLigar();
          
          
            
          
          
                        System.Console.WriteLine($"Ligando para {resultado}");
          
          
                    }
          
          
                }
          
          
            }

Sem dependências

O tipo de abordagem que utilizamos ganha o nome de injeção de construtor, pois, como diz o nome, a injeção da interface é feita no construtor da classe.

Há, além dessa, outras abordagens para a injeção de dependência, sendo elas:

Injeção por propriedade
Injeção por interface
Injeção por framework

Cada uma possui sua própria forma de implementação, e encorajo fortemente que você pesquise mais afundo sobre DI e IoC.

Há também como utilizarmos um container de injeção de dependência, caso estejamos lidando com muitas interfaces e diversas instancias compartilhadas, o que auxiliaria no gerenciamento delas. Mas este assunto ficará para um próximo tópico.

Forte abraço e obrigado por acompanhar meu conteúdo!

Learn

Support

More Options