J'ai vu plusieurs recommander l'utilisation de conteneurs IoC dans le code. La motivation est simple. Prenez le code injecté de dépendance suivant:
class UnitUnderTest
{
std::auto_ptr<Dependency> d_;
public:
UnitUnderTest(
std::auto_ptr<Dependency> d = std::auto_ptr<Dependency>(new ConcreteDependency)
) : d_(d)
{
}
};
TEST(UnitUnderTest, Example)
{
std::auto_ptr<Dependency> dep(new MockDependency);
UnitUnderTest uut(dep);
//Test here
}
Dans:
class UnitUnderTest
{
std::auto_ptr<Dependency> d_;
public:
UnitUnderTest()
{
d_.reset(static_cast<Dependency *>(IocContainer::Get("Dependency")));
}
};
TEST(UnitUnderTest, Example)
{
UnitUnderTest uut;
//Test here
}
//Config for IOC container normally
<Dependency>ConcreteDependency</Dependency>
//Config for IOC container for testing
<Dependency>MockDependency</Dependency>
(Ce qui précède est un exemple hypothétique C ++ bien sûr)
Bien que je convienne que cela simplifie l'interface de la classe en supprimant le paramètre constructeur de dépendance, je pense que le remède est pire que la maladie pour deux raisons. Tout d'abord, et c'est un gros problème pour moi, cela rend votre programme dépendant d'un fichier de configuration externe. Si vous avez besoin d'un déploiement binaire unique, vous ne pouvez tout simplement pas utiliser ces types de conteneurs. Le deuxième problème est que l'API est désormais faiblement et pire, typée de manière stricte . La preuve (dans cet exemple hypothétique) est l'argument chaîne du conteneur IoC et la conversion du résultat.
Alors .. y a-t-il d'autres avantages à utiliser ces types de conteneurs ou est-ce que je suis en désaccord avec ceux qui recommandent les conteneurs?