Pourquoi injecter des dépendances?

Question

En supposant que j'utilise un conteneur IoC, pourquoi exactement mes types ont-ils leurs dépendances injecté? Pourquoi chaque type ne peut-il pas simplement supposer que le conteneur existe et récupérer simplement les dépendances dont il a besoin? Quels sont les inconvénients de cette dernière approche?

Je suis conscient de l'injection de propriétés, mais je ne veux pas que cela soit suggéré comme une réponse, même si cela permet d'économiser de longs constructeurs de listes de paramètres dans des types plus complexes. Et cela ne sauvegarde pas le code que vous devez finalement taper/maintenir. Oh, et je préférerais avoir les dépendances en lecture seule/finale (préférence personnelle).

Alors, voici un exemple typique d'injection constructeur en C#:

public class Calculator 
{ 
    private readonly IAdder _adder; 
    private readonly ISubtractor _subtractor; 
    private readonly IMultiplier _multiplier; 
    private readonly IDivider _divider; 

    public Calculator(IAdder adder, ISubtractor subtractor, 
         IMultiplier multiplier, IDivider divider) 
    { 
     _adder = adder; 
     _subtractor = subtractor; 
     _multiplier = multiplier; 
     _divider = divider; 
    } 
} 

Et voici ce que je préfère faire:

public class Calculator 
{ 
    private readonly IAdder _adder; 
    private readonly ISubtractor _subtractor; 
    private readonly IMultiplier _multiplier; 
    private readonly IDivider _divider; 

    public Calculator() 
    { 
     _adder = Container.Get<IAdder>(); 
     _subtractor = Container.Get<ISubtractor>(); 
     _multiplier = Container.Get<IMultiplier>(); 
     _divider = Container.Get<IDivider>(); 
    } 
} 

Je voudrais maintenir une liste des avantages et des inconvénients que les réponses viennent:

PROS

• Les constructeurs propres en tant que types n'ont pas besoin de "polluer" leurs constructeurs avec des dépendances. Ce n'est pas un gros problème ici car Calculator n'a rien d'autre dans son constructeur que les dépendances mais imaginez-le. Par exemple. public Calculator(Mode mode, bool UseDigitGrouping).
• Le code client ne se casse pas lorsque les dépendances d'une dépendance changent.
• Moins de code à maintenir.

CONS:

• plus difficile de changer conteneur IoC à l'avenir.
• Il n'est pas immédiatement clair quelles sont les dépendances d'un type.

Answer 1

En supposant que je utilise un conteneur IoC, pourquoi exactement mes types doivent avoir toutes leurs dépendances injectées? Pourquoi tous les types ne peuvent-ils pas supposer que le conteneur existe et qu'il récupère simplement les dépendances dont il a besoin pour lui-même? Quels sont les inconvénients à cela?

Quelques raisons que je peux penser, dont vous évoquez un:

• Il n'est plus apparent quelles dépendances votre classe a, le cas échéant
• La classe prendra une dépendance cachée le conteneur, de la pire sorte, pas moins (en supposant qu'il existe soit globalement ou est accessible statiquement)

Votre préoccupation concernant la facilité d'adaptation du code quand cha dépend d'une dépendance nge est valide; c'est un argument très fort pour IoC (laissez le conteneur le faire automatiquement pour vous, tant qu'il est possible de satisfaire toutes les dépendances, rien ne se brise).