Injection de dépendances en .Net Core [ Partie 3 : Container IOC]

var mainView = new MainView(new OpelService());

Nous pourrions injecter manuellement les dépendances dans nos classes. Mais cela deviendrait vite compliqué dans un programme complexe. Si notre classe MainView a besoin d’une dépendance supplémentaire, il faudra repasser dans toutes les instanciations de cette dernière. Ou si notre classe OpelService a également besoin d’une nouvelle dépendance, l’instanciation de la classe MainView pourrait devenir compliquée.

Nous allons donc utiliser un Container IOC (Inversion of Control). Son rôle est de gérer automatiquement l’injection de dépendances dans nos classes et également d’instancier ces dernières. Et cerise sur le gâteau, lorsque vous créez un projet en .Net Core, un container IOC est inclus dans votre projet. Pour comprendre comment fonctionne ce dernier, il faut ouvrir le fichier Startup.cs (Version .Net Core 3.1).

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseRouting();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

Nous allons nous intéresser à la méthode ConfigureServices. C’est dans cette méthode que toute la magie opère. Cette méthode reçoit un paramètre services de type IServiceCollection. Si vous prenez le temps mettre un point d’arrêt sur cette méthode, vous constaterez que la variable services est de type ServiceCollection.

Ci-dessous, la liste des méthodes et des propriétés de la classe ServiceCollection.

Nous pouvons constater que la classe ServiceCollection possède simplement une liste de ServiceDescriptor et des méthodes pour mettre à jour cette liste. Nous n’utiliserons jamais ces méthodes, vous comprendrez pourquoi un peu plus tard dans ce tutoriel. Prenons d’abord le temps de comprendre la classe ServiceDescriptor.

L’image ci-dessus ne représente qu’une petite partie de ce que permet cette classe, mais est suffisante pour comprendre comment elle fonctionne. Ce qu’il faut retenir, c’est que cette classe possède les 5 propriétés suivantes :

• ServiceType et ImplementationType : Le ServiceType correspond à l’interface qui sera utilisée dans nos constructeurs. L’ImplementationType correspond à classe qui implémente le ServiceType. Dans nos précédents exemples, le ServiceType correspond à l’interface ICarService, et l’ImplementationType à la classe OpelService.
• ImplementationInstance : Lorsque nous enregistrons une dépendance, il est possible de lui fournir directement l’instanciation de la classe à injecter dans les constructeurs. Cette instanciation sera enregistrée dans la propriété ImplementationInstance.
• ImplementationFactory : Si l’instanciation de votre objet ImplementationType est complexe, vous pouvez définir la façon dont l’objet sera instancié lorsque ce dernier doit être injecté dans un constructeur. Ça peut être utile par exemple lorsque vous souhaitez intégrer l’injection de dépendance dans un projet où cette dernière n’est pas du tout utilisée.
• Lifetime : Lorsque vous enregistrez une dépendance, vous pouvez choisir d’enregistrer en tant que Singleton, Scoped ou Transient. La différence entre les 3 sera expliquée dans la prochaine partie de ce tutoriel.

Dans la partie suivante de ce tutoriel, nous allons voir comment enregistrer nos dépendances en utilisant le Container IOC natif à .Net Core.