Design patterns
Injection de dépendance
Recherche…
Introduction
L'idée générale derrière l'injection de dépendance est que vous concevez votre application autour de composants faiblement couplés tout en adhérant au principe d'inversion de dépendance. En ne dépendant pas d'implémentations concrètes, permet de concevoir des systèmes hautement flexibles.
Remarques
L'idée de base de l'injection de dépendance est de créer un code plus faiblement couplé. Lorsqu'une classe, plutôt que de mettre à jour ses propres dépendances, prend plutôt ses dépendances, la classe devient plus simple à tester en tant qu'unité ( test unitaire ).
Pour développer davantage le couplage lâche - l'idée est que les classes deviennent dépendantes des abstractions, plutôt que des concrétions. Si la classe A dépend d'une autre classe concrète B , alors il n'y a pas de test réel de A sans B Bien que ce type de test puisse être correct, il ne se prête pas au code testable de l’unité. Une conception faiblement couplée définirait une abstraction IB (par exemple) dont dépendrait la classe A On peut alors simuler IB pour fournir un comportement testable, plutôt que de compter sur l'implémentation réelle de B pour pouvoir fournir des scénarios testables à A
Exemple à couplage étroit (C #):
public class A
{
public void DoStuff()
{
B b = new B();
b.Foo();
}
}
Dans ce qui précède, la classe A dépend de B Il n'y a pas de test A sans le béton B Bien que ce soit bien dans un scénario de test d'intégration, il est difficile de test unitaire A .
Une implémentation plus souple de ce qui précède pourrait ressembler à ceci:
public interface IB
{
void Foo();
}
public class A
{
private readonly IB _iB;
public A(IB iB)
{
_iB = iB;
}
public void DoStuff()
{
_b.Foo();
}
}
Les deux implémentations semblent assez similaires, il y a cependant une différence importante. La classe A ne dépend plus directement de la classe B , elle dépend maintenant de IB . La classe A n’a plus la responsabilité de renouveler ses propres dépendances - elles doivent maintenant être fournies à A
Injection Setter (C #)
public class Foo
{
private IBar _iBar;
public IBar iBar { set { _iBar = value; } }
public void DoStuff()
{
_iBar.DoSomething();
}
}
public interface IBar
{
void DoSomething();
}
Constructeur Injection (C #)
public class Foo
{
private readonly IBar _iBar;
public Foo(IBar iBar)
{
_iBar = iBar;
}
public void DoStuff()
{
_bar.DoSomething();
}
}
public interface IBar
{
void DoSomething();
}