Dans un précédent article, je vous parlais de la mise en place de WEB Api avec les instructions MVC 4. Dans l’article, je ne parlais pas d’injection de dépendance, très souvent utilisée avec NHibernate par exemple (ce qui est mon cas).
Pour cela quelques étapes sont nécessaire pour faire le paramétrage de cette injection. MVC a déjà tout prévu pour nous :)
- Modification du Global.asax
- Utilisation de IHttpControllerActivator
- Utilisation de Windsor Castle
De ce faite, c’est ce container qui construira/fabriquera/instanciera a la demande les objets nécessaire a l’exécution du code. L’intérêt de cette méthode est de rendre autonome au maximum nos classes (dépendance). Généralement cette dépendance, se voit au constructeur; ce dernier disposera alors comme paramètre l’ensemble des dépendances a résoudre lors de l’instanciation.
Ce n’est pas une notion facile a appréhender / comprendre. Moi même j’ai eu beaucoup de mal au début. Cependant, l’intérêt est tout de suite parlant dès lors ou vous avez a faire a des projet utilisant, ou nécessitant l’utilisation de ce mécanisme.
Global.asax
Le point d’entré de l’application permet d’exécuter le paramétrage de notre/nos injection(s). Dans notre cas, nous alors donc remplacer la “routine” du Controller sur nos Web API, par notre propre “Activator” qui se positionnera donc entre la demande de la requête et son traitement. Permettant ainsi de résoudre, et de fournir le contrôleur adéquate (comprendre: Castle.Windors instanciera alors notre Controller avec les dépendances et le retournera a MVC).Il est important de noter qu’il faut distinguer les routes de type WebAPI et les autres (mvc classique). L’injection ne sera pas la même, on passera alors par la fabrique de controller (ControllerBuilder.Current.SetControllerFactory(controllerFactory) )
protected void Application_Start()
{
[…]
GlobalConfiguration.Configuration.Services.Replace(typeof(System.Web.Http.Dispatcher.IHttpControllerActivator), new WindsorCompositionRoot(container.Kernel));
}
IHttpControllerActivator
Une fois l’appel fait dans notre Application_Start, nous fournissons alors a notre Activator le Kernel (notre container de référence), pour que ce dernier puisse piocher dedans afin de faire l’instanciation.L’interface est assez simple; 2 méthodes
- Create : création du controller en question, on va résoude (resolve) dans notre container la référence, et retourner ce dernier.
- Le Dispose, il faut lors de la fin d’execution de la requete HTTP (webapi) que les ressources acquises soient libérées. On implemente alors un classe Disposable, utilisable a l’aide de RegisterForDispose.
public class WindsorCompositionRoot : IHttpControllerActivator
{
private readonly IKernel kernel;
public WindsorCompositionRoot(IKernel kernel)
{
this.kernel = kernel;
}
public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType)
{
var controller = (IHttpController)this.kernel.Resolve(controllerType);
request.RegisterForDispose(new RessCtrlRelease(this.kernel, controller));
return controller;
}
private class RessCtrlRelease : IDisposable
{
private readonly IKernel kernel;
private IHttpController httpController;
public RessCtrlRelease(IKernel kernel, IHttpController httpController)
{
this.kernel = kernel;
this.httpController = httpController;
}
public void Dispose()
{
this.kernel.ReleaseComponent(this.httpController);
}
}
}
Je ne sais pas si j’ai été suffisamment clair, c’est un sujet assez vague et complexe, mais j’espère que les bouts d’informations que j’ai mise en place permettront d’éclaircir et d’aider les développeurs que nous sommes.
Parce que beaucoup d’information existe sur la toile, un article m’a beaucoup aider : http://blog.ploeh.dk/2012/04/17/InjectingHttpControllerContextWiththeASP.NETWebAPI/
Articles en relation :
