A Injeção de Dependência do Pobre Homem é uma boa maneira de introduzir testabilidade em um aplicativo herdado?

No ano passado, criei um novo sistema usando Injeção de Dependência e um contêiner de COI. Isso me ensinou muito sobre DI!

No entanto, mesmo depois de aprender os conceitos e os padrões adequados, considero um desafio desacoplar o código e introduzir um contêiner IOC em um aplicativo herdado. O aplicativo é grande o suficiente para o ponto em que uma implementação verdadeira seria esmagadora. Mesmo que o valor tenha sido entendido e o tempo concedido. Quem concedeu tempo para algo assim?

O objetivo do curso é trazer testes de unidade para a lógica de negócios!
Lógica comercial interligada com chamadas de banco de dados que impedem testes.

Li os artigos e compreendo os perigos da Injeção de Dependência do Pobre Homem, conforme descrito neste artigo da Los Techies . Eu entendo que isso realmente não dissocia nada.
Entendo que isso pode envolver muita refatoração em todo o sistema, pois as implementações exigem novas dependências. Eu não consideraria usá-lo em um novo projeto com qualquer quantidade de tamanho.

Pergunta: Tudo bem usar o DI da Poor Man para introduzir testabilidade em um aplicativo herdado e começar a bola rolar?

Além disso, o uso do DI de Poor Man como uma abordagem básica da injeção de dependência verdadeira é uma maneira valiosa de educar sobre a necessidade e os benefícios do princípio?

Você pode refatorar um método que possui uma dependência de chamada de banco de dados e um resumo que chama atrás de uma interface? Simplesmente ter essa abstração tornaria esse método testável, pois uma implementação simulada poderia ser passada através de uma sobrecarga de construtor.

Mais adiante, uma vez que o esforço ganhe adeptos, o projeto poderá ser atualizado para implementar um contêiner do COI e os construtores estarão lá fora, captando as abstrações.

A crítica sobre a Injeção do Pobre Homem no NerdDinner tem menos a ver com o uso ou não de um DI Container do que com a configuração correta de suas aulas.

No artigo, eles afirmam que

public class SearchController : Controller {

    IDinnerRepository dinnerRepository;

    public SearchController() : this(new DinnerRepository()) { }

    public SearchController(IDinnerRepository repository) {
        dinnerRepository = repository;
    }
}

está incorreto porque, embora o primeiro construtor forneça um mecanismo de fallback conveniente para a construção da classe, ele também cria uma dependência fortemente vinculada a DinnerRepository.

O remédio correto, obviamente, não é, como sugere o Los Techies, adicionar um contêiner de DI, mas remover o construtor ofensivo.

public class SearchController : Controller 
{
    IDinnerRepository dinnerRepository;

    public SearchController(IDinnerRepository repository) {
        dinnerRepository = repository;
    }
}

A classe restante agora tem suas dependências devidamente invertidas. Agora você está livre para injetar essas dependências da maneira que desejar.

Você faz uma suposição falsa aqui sobre o que é "DI do pobre homem".

Criar uma classe que tenha um construtor de "atalho" que ainda crie acoplamento não é um DI de pobre.

Não usar um contêiner e criar manualmente todas as injeções e mapeamentos é o DI do pobre homem.

O termo "DI do pobre homem" parece uma coisa ruim a se fazer. Por esse motivo, o termo "DI puro" é incentivado atualmente , pois soa mais positivo e na verdade descreve com mais precisão o processo.

Não apenas é absolutamente bom usar o DI de homem pobre / puro para introduzir o DI em um aplicativo existente, mas também é uma maneira válida de usar o DI em muitos aplicativos novos. E, como você diz, todos devem usar o DI puro em pelo menos um projeto para realmente entender como o DI funciona, antes de assumir a responsabilidade pela "mágica" de um contêiner de IoC.

Mudanças de Paragidm em equipes legadas / bases de código são extremamente arriscadas:

Sempre que você sugere "melhorias" no código legado e há programadores "legados" na equipe, você está apenas dizendo a todos que "eles fizeram de errado" e você se torna O Inimigo pelo resto do seu tempo na empresa.

Usar um DI Framework como um martelo para esmagar todos os pregos tornará o código legado pior do que melhor em todos os casos. Também é extremamente arriscado pessoalmente.

Mesmo nos casos mais limitados, apenas para que ele possa ser usado em casos de teste, esses códigos de código "não padrão" e "estrangeiro" serão apenas marcados @Ignorequando forem quebrados ou, pior ainda, reclamados constantemente pelo programadores legados com mais influência no gerenciamento e são reescritos "corretamente" com todo esse "desperdício de tempo em testes de unidade", atribuído exclusivamente a você.

A introdução de uma estrutura de DI, ou mesmo o conceito de "Pure DI" em um aplicativo de linha de negócios, muito menos uma enorme base de códigos herdada sem a administração, a equipe e, principalmente, o patrocínio do desenvolvedor líder serão o ponto de partida. para você social e politicamente na equipe / empresa. Fazer coisas assim é extremamente arriscado e pode ser um suicídio político da pior maneira.

Injeção de Dependência é uma solução que procura um problema.

Qualquer linguagem com construtores por definição usa injeção de dependência por convenção, se você sabe o que está fazendo e entende como usar adequadamente um construtor, esse é apenas um bom design.

A injeção de dependência é útil apenas em pequenas doses para uma gama muito estreita de coisas:

• Coisas que mudam muito ou têm muitas implementações alternativas vinculadas estaticamente.

  • Os drivers JDBC são um exemplo perfeito.
  • Clientes HTTP que podem variar de plataforma para plataforma.
  • Sistemas de log que variam de acordo com a plataforma.

• Sistemas de plug-in que possuem plug-ins configuráveis ​​que podem ser definidos no código de configuração em sua estrutura e descobertos automaticamente na inicialização e carregados / recarregados dinamicamente enquanto o programa está em execução.