L’injection de dépendances en ASP.NET Core 1.0

L’injection de dépendances est de plus en plus utilisée dans les projets, notamment grâce à la flexibilité qu’elle apporte en terme de découpage de code, d’évolutivité, ... Pour ceux qui l’utilisent au quotidien dans leurs applications, les applications Web ne dérogent pas à la règle et permettent maintenant de le gérer nativement ! En effet, avec ASP.NET Core 1.0, l’injection de dépendances est au cœur du Framework, ce qui signifie qu’il n’est donc plus nécessaire d’ajouter son propre outil d’injection de dépendances (Conteneur d’inversion de contrôle ou IoC).

Comment utiliser l’injection de dépendance en ASP.NET Core 1.0 ?

Pour utiliser l’injection native proposée par le Framework, il faut enregistrer vos dépendances dans la méthode ConfigureServices située dans la classe Startup de votre application. Dans cette méthode, nous avons accès à une IServiceCollection qui nous permet d’enregistrer nos dépendances. Il existe alors plusieurs manières d’enregistrer une dépendance et ce en fonction de la durée de vie que nous souhaitons lui donner. Voici les différentes durées de vie disponibles :

  • « Transient » : le service est créé à chaque fois qu’il doit être résolu (si mon service est injecté au niveau du contrôleur et au niveau d’un autre service, 2 instances seront donc créées).
  • « Scoped » : le service est créé une seule fois et ce pour chaque requête.
  • « Singleton » : le service est créé dès la première requête à l’application et est perduré durant toutes les prochaines requêtes.

Voici un exemple permettant de voir la différence (avec des valeurs de Guid) entre ces 3 durées de vie.

aspnetcore-dependances

 

 

Avec cette illustration, on visualise bien la différence entre les différentes durées de vie. Il faut donc bien choisir pour ne pas avoir de surprise et pour que ce choix soit bien adapté à votre besoin. Une fois ce choix effectué, il faut enregistrer la dépendance dans votre application Web. Voici quelques exemples d’enregistrement de dépendances (objets instanciés, relations interface/implémentation, …) :

public void ConfigureServices(IServiceCollection services)
{
    // Exemple d'injection de services natifs d'ASP.NET Core 1.0
    services.AddTransient<IHttpContextAccessor, HttpContextAccessor>();
    services.AddSingleton<IActionContextAccessor, ActionContextAccessor>()

    // Exemple d'injection personnalisée
    services.AddScoped<IStorageFileService, BlobStorageService>(); 
    services.AddTransient<QueueManager>();   
    services.AddTransient<Func<Guid, IEventDbContext>>(options => ((id) => new EventDbContext(id)));
}

 

Vos dépendances étant maintenant enregistrées, vous n’avez plus qu’à les utiliser, et ce un peu partout dans votre application Web, grâce notamment à l’injection par le constructeur. Le plus couramment utilisé restant l’injection dans les contrôleurs, en voici donc un exemple :

public class EventsController : Controller
{
    private readonly IStorageFileService storageFileService;
    private readonly Func<Guid, IEventDbContext> eventContextFactory;
    private readonly IHttpContextAccessor httpContextAccessor;
    private readonly QueueManager queueManager;

    // Tous ces paramètres étant enregistrés ci-dessus
    // Ils seront automatiquement résolus en fonction de la configuration du conteneur
    public EventsController(Func<Guid, IEventDbContext> eventContextFactory, 
        QueueManager queueManager, 
        IStorageFileService storageFileService, 
        IHttpContextAccessor httpContextAccessor)
    {
        this.currentEventContextFactory = currentEventContextFactory;
        this.storageFileService = storageFileService;
        this.queueManager = queueManager;
        this.httpContextAccessor = httpContextAccessor;
    }
}


Pour ce qui est de l’utilisation de l’injection de dépendances dans les filtres, il est nécessaire également d’enregistrer le filtre, pour ceux qui souhaitent en savoir plus sur ce point, je vous invite à lire mon article qui traite de cela : http://blogs.infinitesquare.com/b/tdesmas/archives/injection-de-dependance-dans-les-filtres-en-aspnet-core-1.

Allez plus loin

Il est également possible pour ceux qui le souhaitent de remplacer le conteneur d’injection de dépendances qu’utilise nativement ASP.NET Core 1.0. En fonction des besoins, la création de son propre conteneur peut être nécessaire pour des raisons de performance, d’habitude ou autre. Mais jusqu’a présent, dans les projets en ASP.NET Core que j’ai pu rencontrer, je n’ai jamais eu besoin de créer mon propre conteneur d’injection.

Pour cela, il faut changer la signature de retour de la méthode ConfigureServices vue auparavant, de “void” à “IServiceProvider”.

public IServiceProvider ConfigureServices(IServiceCollection services)
{
  // Configurer le conteneur et le retourner
}
Si vous ne souhaitez pas écrire votre conteneur, vous pouvez utiliser Autofac qui est supporté sous ASP.NET Core (http://docs.autofac.org/en/latest/integration/aspnetcore.html). Unity, qui est souvent le plus connu et le plus utilisé en C# ne supporte pas encore ASP.NET Core.

 

N’hésitez donc pas à utiliser au maximum l’injection de dépendances dans vos projets futurs pour profiter un maximum des atouts qu’il fournit !

Photo de profil

Ces billets pourraient aussi vous intéresser

Vous nous direz ?!

Commentaires

comments powered by Disqus