Dans cet article on va utiliser Spring.NET pour faire de l’injection de dépendances au sein de l’exemple précédemment établit dans le premier article et modifié dans le second . Pour cela on va tout d’abord télécharger et installer Spring.NET.
Le framework Spring.NET est basé sur la version java du framework Spring. Il permet de faciliter et d'accélérer le développement d'applications .NET en proposant des implémentations de différentes fonctionnalités comme la programmation orientée aspect (AOP), l'accès aux données avec NHibernate ou encore l'injection de dépendances.
Comme tous les frameworks implémentant l’injection de dépendances, Spring.NET met à disposition un container permettant de résoudre les dépendances. Il faut bien entendu signifier à ce dernier les dépendances avant de lui demander de les résoudre.
Côté implémentation c’est totalement différent des implémentations des autres frameworks. La déclaration des dépendances se fait dans le fichier de configuration .config
On va commencer par ajouter la référence à Spring.Core.dll dans le projet console.
Pour pouvoir charger cette dll, il suffit de rajouter à votre app.config les lignes suivantes :
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
...
<configSections>
<sectionGroup name="spring">
<section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core" />
<section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" />
</sectionGroup>
</configSections>
...
</configuration>
Si vous n’avez pas de fichier .config dans votre projet, vous pouvez le rajouter en faisant click droit sur le projet -> Add -> New Item… et choisir l’élément « Application Configuration File »
Ensuite on va déclarer les dépendances au container de Spring. En fait en ce qui concerne Spring on définit des alias sur les types qu’on veut injecter. Les deux types de classes qu’on va injecter pour notre exemple sont la classe RizAuCurry et la classe Poelle. Pour ce faire il faut rajouter ces quelques lignes suivantes dans le fichier de config :
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
...
<spring>
<context>
<resource uri="config://spring/objects" />
</context>
<objects xmlns="http://www.springframework.net">
<object name="Plat" type="DemoLibrary.Implementation.RizAuCurry, DemoLibrary" singleton="false" />
<object name="Ustensile" type="DemoLibrary.Implementation.Poelle, DemoLibrary" singleton="false" />
</objects>
</spring>
...
</configuration>
La balise Object nous permet de définir un alias vers un type. L’attribut name correspond à l’alias, l’attribut type est composé de 2 parties : le namespace + nom de la classe et le nom de la dll. Enfin l’attribut singleton permet de spécifier si c’est un singleton.
Ensuite, on va créer un « wrapper » sur le container de Spring, qui va juste nous renvoyer le container lorsqu’on en a besoin. On pourrait bien évidemment se passer de cette étape mais un peu d’organisation ça ne fait pas de mal.
using Spring.Context;
using Spring.Context.Support;
public static class Context
{
private static IApplicationContext applicationContext = null;
static Context()
{
applicationContext = ContextRegistry.GetContext();
}
public static IApplicationContext ApplicationContext
{
get { return applicationContext; }
}
}
Maintenant il ne reste plus qu’à écrire le code principal dans notre projet console et au lieu d’instancier directement les classes on va demander au container Spring de nous renvoyer une instance du type dont on a besoin.
class Program
{
static void Main(string[] args)
{
//Le container Spring renvoye un objet qui
//correspond ? l'alias Plat
IPlat plat = (IPlat)Context.ApplicationContext["Plat"];
//Le container Spring renvoye un objet qui
//correspond ? l'alias Ustensile
IUstensile ustensile = (IUstensile)Context.ApplicationContext["Ustensile"];
//Instaciation de la classe Cuisinier
Cuisinier chef = new Cuisinier(ustensile,plat);
Console.WriteLine(chef.Cuisiner());
Console.Read();
}
}
Voici le résultat :
Avantages
L’implémentation de l’injection de dépendances avec le framework Spring.NET offre beaucoup d’avantages :
- Le fait d’utiliser le fichier de config pour la déclaration des alias présente un avantage certain qui est de pouvoir changer la classe vers laquelle pointe un alias sans avoir besoin de recompiler tout le code.
Inconvénients
- Pas de résolution récursive de dépendances, on doit explicitement demander au container les objets correspondant aux alias dont on a besoin.
- Le container n’est pas générique ce qui nous oblige à faire un cast à chaque fois que ce dernier nous renvoie un objet.
- La déclaration des alias au sein du fichier de config peut être une source d’erreurs lors de l’exécution puisque ce n’est pas du compilé.
Conclusion :
Spring.NET est un bon framework d’injection de dépendances grâce à son côté souple concrétisé par l’utilisation du fichier de config mais je dois avouer que le fait de ne pas avoir la résolution récursive de dépendances est un inconvénient non négligeable et qui est à mon avis éliminatoire au sein d’un grand projet.