Desde que comecei meus estudos com arquitetura de software passei a prezar mais pela qualidade do código e a facilidade de trabalhar com boas práticas. Existe um padrão chamado Injeção de Dependência no qual será assunto deste breve post. O que é e para que serve? Como utilizá-lo? São questões que tentarei abordar durante o post.
O que é Injeção de Dependência e para que serve?
Segundo a Wikipédia, Injeção de Dependência é um padrão de desenvolvimento de software utilizado quando necessitamos manter um baixo acoplamento entre as camadas (módulos) de um sistema. Mas o que seria este acoplamento? O acoplamento dá-se a partir do momento em que você gera uma nova instância direta de uma classe que pertence a outro módulo em um segundo módulo, ou seja, este passa a depender diretamente daquele tipo e não de uma abstração. Um exemplo simplista disso:
public class CompraService {
public void PagarCompra(Compra compra) {
var repositorio = new RepositorioDeCompra();
repositorio.PagarCompra(compra);
}
}
Neste exemplo, a partir do momento que definimos uma instância do RepositorioDeCompra() (linha 3) em nosso serviço, estamos acoplando diretamente nosso repositório ao serviço. Ou seja, ele depende diretamente da referência da classe RepositorioDeCompra. Isso funciona perfeitamente, mas poderíamos melhorar um pouco a fim de desacoplar nosso serviço.
Mas como podemos melhorar isso?
É possível realizar uma abstração utilizando uma interface, ou seja, depender de uma implementação de uma interface ao invés de uma classe concreta. Com isso temos a vantagem de mudar a instância no momento em que necessitarmos um exemplo:
public class CompraService {
protected IRepositorioDeCompra Repositorio {
get;
private set;
}
public CompraService(IRepositorioDeCompra repositorio) {
this.Repositorio = repositorio;
}
public void PagarCompra(Compra compra) {
this.Repositorio.PagarCompra(compra);
}
}
Podemos ver que no exemplo, utilizamos uma abstração do RepositorioDeCompra, ou seja, uma interface que contém assinaturas de métodos que devem ser implementados pela instância a ser passada no construtor do serviço (que deixa explícito o requisito; podemos trabalhar com dependência em propriedades ou parâmetro em métodos; em tempo vamos entender o conceito em construtores). Isso nos da uma flexibilidade maior, pois podemos passar qualquer objeto de uma classe que implemente esta interface, mantendo o baixo acoplamento entre a camada de serviço e sua intermediaria. E para finalizar um exemplo desta interface e suas implementações:
interface IRepositorioDeCompra {
void Salvar(Compra compra);
void Excluir(Compra compra);
IEnumerable<Compra> ObterTodos();
Compra Obter(int id);
void PagarCompra(Compra compra);
void ReceberCompra(Compra compra);
void CancelarCompra(Compra compra);
}
public class RepositorioDeCompra : IRepositorioDeCompra { ... }
public class RepositorioDeCompraNHibernate : IRepositorioDeCompra { ... }
public class RepositorioDeCompraEF : IRepositorioDeCompra { ... }
public class RepositorioDeCompraAdo : IRepositorioDeCompra { ... }
public class RepositorioDeCompraXml : IRepositorioDeCompra { ... }
Com isso, podemos passar qualquer uma dessas instâncias, pois estas implementam IRepositorioDeCompra. Na prática isso poderia ser utilizado da seguinte forma:
var servico = new CompraService(new RepositorioDeCompraNHibernate());
var servico = new CompraService(new RepositorioDeCompraEF());
var servico = new CompraService(new RepositorioDeCompraAdo());
Apesar de ser simples o assunto, recomendo que utilizem um container de dependências, que será assunto para um próximo post.
Espero que tenham gostado e entendido.
Um abraço!
Referências:
http://en.wikipedia.org/wiki/Dependency_injection
http://viniciusquaiato.com/blog/injecao-de-dependencia/