Unity – Introduction à l’IoC selon Microsoft

Il existe de nombreux frameworks disponibles pour réaliser de l'IoC en .Net, comme par exemple Spring, Ninject, Simple IoC, etc…
Microsoft nous propose également sa solution maison pour la mettre en place avec Unity Framework.

Unity rentrera d’ailleurs dans sa version 3.0 pour gérer le framework .Net 4.5 (pour .Net 3.5 et 4.0, il faut utiliser Unity 2.1).
Cet article se base sur Unity 2.1 sous Visual Studio 2010, la version 3.0 n’étant pas encore finalisée

Pour voir comment le mettre en place, imaginons le cas d’école simple suivant : Je veux injecter un objet Contact qui sera représenté par la classe Contact (avec un nom, prénom, adresse, numéro de téléphone). Cet objet sera injecté dans ma page par Unity, et pour raccourcir le cas d’école, nous injecterons également les propriétés dans l’objet contact, ce qui nous permettra de voir en chemin l’injection de propriété.

Bien, maintenant que le sujet est posé, commençons par créer un projet WPF dans Visual Studio : 1_IntroUnity_CreateProject

Ensuite à l’aide de Nuget (clic droit sur la solution, gérer les packages NuGet), nous allons installer les références au framework Unity : 2_IntroUnity_AddUnity

Créons notre classe Contact simple contenant 4 propriétés :

public class Contact {     public string Nom { get; set; }     public string Prenom { get; set; }     public string Adresse { get; set; }     public string Numero { get; set; } }

Passons à la configuration d' Unity pour injecter les propriétés et ensuite l’objet contact dans la MainWindow Dans le fichier App.config, on ajoute la référence au fichier de configuration Unity ainsi qu’à ses namespaces. Notre fichier App.config doit ressembler à ceci :

<?xml version="1.0" encoding="utf-8" ?> <configuration>   <configSections>     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />   </configSections>   <unity configSource="Unity\Unity.config" /> </configuration>

Et le contenu du fichier Unity.config en lui-même :

<unity xmlns="http://schemas.microsoft.com/practices/2010/unity">   <!-- ********** Configuration des assemblies ********** !-->   <assembly name="DemoUnity" />   <!-- ********** Configuration des namespace ********** !-->   <namespace name="DemoUnity" />   <containers>     <container>       <!-- ********** Configuration de l'objet contact ********** !-->       <register type="Contact" mapTo="Contact">         <property name="Nom" value="ALEXANDRE" />         <property name="Prenom" value="Thibaut" />         <property name="Adresse" value="Rue Mogador, Paris" />         <property name="Numero" value="01.02.03.04.05" />       </register>     </container>   </containers> </unity>

Analysons un peu ce fichier : - Les balises Assembly et Namespace vont servir à déclarer à Unity ses références. C’est à l’aide de ces balises qu’Unity retrouvera les objets qu’on lui déclare. - La balise container ensuite contient ce que chaque container unity va posséder lors du chargement de sa configuration (il est possible d’en déclarer plusieurs dans la même balise, il faudra alors préciser à la création de l’objet container laquelle doit être chargée) - La balise register déclare un type et son mappage. C’est ici qu’Unity va faire la liaison entre l’objet et son type. Les résolutions sont ici simples, mais c’est bien entendu ici que se fait l’essentiel du travail quand on travaille avec des interfaces par exemple.

Ce sujet pourra être développé dans un autre article, nous allons nous concentrer sur le mécanisme d’injection dans un premier temps.

- Les balises property définissent les propriétés qu’Unity va injecter dans le constructeur de l’objet enregistré. Inutile de préciser le type ici, Unity ira seul rechercher le type de la propriété grâce à son nom et fera la liaison avec le type à injecter. Comme on le remarque pour le contact, on peut également définir une valeur à injecter en même temps via le fichier de config.

Il nous reste à charger le container au lancement de notre MainWindows, déclarer l’objet contact et le résoudre via Unity :

using System.Windows; using Microsoft.Practices.Unity; using Microsoft.Practices.Unity.Configuration; namespace DemoUnity {     /// <summary>     /// Logique d'interaction pour MainWindow.xaml     /// </summary>     public partial class MainWindow : Window     {         public Contact currentContact { get; set; }         public MainWindow()         {             IUnityContainer container = new UnityContainer().LoadConfiguration();             currentContact = container.Resolve<Contact>();             InitializeComponent();         }     } }

En ajoutant un binding WPF (n’étant pas le sujet ici, je vous laisse vous renseigner dessus, avec par exemple les 2 Technical Breakfasts sur ce sujet 😉 ), le tour est joué :

3_IntroUnityUnityfinal

Conclusion : Nous avons vu ici comment résoudre un objet Contact directement dans le code (utile pour résoudre un objet lorsqu’on ne peut pas accéder au constructeur, comme sur une page aspx), contact dans lequel nous avons injecté 4 propriétés avec leurs valeurs directement dans le constructeur de l'objet. Et le tout très simplement, avec très peu de lignes de codes.

Vous trouverez la solution de cette article ici : DemoUnity

Si vous voulez aller plus loin, il est un peu difficile de trouver de « bons » tutoriels, exemples et/ou documentations sur le net, mais je vous conseille cet article : http://nathanaelmarchand.developpez.com/tutoriels/dotnet/architecture-couches-decouplage-et-injection-dependances-avec-unity/

Quant à moi, je vous montrerai prochainement comment aller plus loin avec Unity en utilisant le ServiceLocator. A bientôt !

Un commentaire

  1. NHibernate est un framework de mapping objet/relationnel, je ne pense pas qu’il fasse de l’injection. Je me trompe ?

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.