Application de refactoring .Net pour utiliser l'injection de dépendances

Question

Je suis actuellement dans la phase de test d'un projet sur lequel je travaille et j'ai du mal à mettre le service principal sous test dans autre chose que les cas de test par défaut les plus basiques.

Le Service est actuellement responsable de la création de tous les sous-composants, que je voudrais modifier pour utiliser un conteneur IoC.

Quel contenant dois-je utiliser pour factoriser rapidement à une configuration simple IoC, tout ce que je besoin est d'injecter les componets lsited dans le constructeur suivant:

public DataService(string applicationFolder, string pluginFolder, 
     string persistantCacheDirectory, string settingsFolder, 
     string colorsFolder, string templatesFolder) 
{ 

    _DataSourceLoaderPlugins = new DataSourceLoaderPlugins(pluginFolder, 
            applicationFolder, defaultConnectionString); 
    _DataSourcesService = new DataSourceService(_DataSourceLoaderPlugins); 

    _ChartPlugins = new ChartPlugins(pluginFolder); 
    //... and about 10 more dependencies 

} 

Je suis nouveau à conteneurs IoC, et je suis Je ne sais pas exactement quel est le meilleur cadre pour mes besoins fondamentaux.

Les constructeurs de composants ont besoin de certains paramètres des paramètres de l'application dans le fichier web.config, ce qui sera aussi compliqué que possible pour ce projet.

Ce service doit également avoir une portée singleton.

Quelles sont les suggestions des utilisateurs? quel cadre est simple, facile à installer et à mettre en route?

Answer 1

Autofac serait un excellent choix ici - il est léger et très facile à démarrer.

Vous enregistrerait votre structure comme celle-ci:

var builder = new ContainerBuilder(); 

// Use the most resolvable constructor 
builder.Register<DataSourceLoaderPlugins>().As<IDataSourceLoaderPlugins>().SingletonScoped(); 

// Use your own instance 
builder.Register(new DataSourcesService("some path")).As<IDataSourcesService>().SingletonScoped(); 

// Reference another component 
builder.Register(c => new ChartPlugins(c.Resolve<IDataSourcesService>(), "another path")).As<IChartPlugins>().SingletonScoped(); 

// ...other ~10 dependencies... 

builder.Register<DataService>().SingletonScoped(); 

// How to resolve an instance 

var container = builder.Build(); 

DataService dataService = container.Resolve<DataService>(); 

(il est le support de configuration XML si vous préférez)

Answer 2

L'infrastructure Unity de Microsoft est bonne! Pas difficile à utiliser!

Answer 3

Je suis un grand fan de StructureMap - Je n'ai pas trouvé que ça prenait énormément d'efforts pour l'utiliser et la communauté est très active, avec le créateur Jeremy Miller particulièrement utile. StructureMap peut certainement faire ce dont vous avez besoin et tout cela est réalisable dans les modèles d'utilisation «standard» - les tutoriels de base devraient vous voir capable de faire tout ce que vous voulez.

Le site StructureMap est un très bon endroit pour commencer, avec beaucoup de tutoriels et d'exemples de code.

Cela dit, je imagerie que la plupart du courant principal des conteneurs répondraient à vos IoC besoins, il est vraiment question de préférence personnelle, des choses comme:

1. Qu'est-ce que les gens savent que vous utilisez? (Pour moi Ninject, StructureMap et Unity)
2. Quels projets Open Source admirez-vous et qu'utilisent-ils? (Pour moi les Alt.Net semblent favoriser StructureMap)
3. Êtes-vous un magasin de Microsoft strict? (Ensuite, Unity est le chemin à suivre - je vais l'utiliser plus car certains de mes clients sont uniquement des sociétés Microsoft)

Si vous voulez un aperçu de ce qui est là pour vous aider à faire dans votre esprit, il y a un grand blog here qui regarde toutes les options principales.

Answer 4

Castle Windsor est très rapide et facile à configurer, voici un excellent tutorial with some examples.

Answer 5

Il y a une comparaison de librtaries IoC ici:

http://elegantcode.com/2009/01/07/ioc-libraries-compared/

je regarderais dans les cadres qui vous permettent de configurer votre application en utilisant à la fois le fichier de configuration et programatically - à l'aide des tests unitaires.