Conteneur d'injection de dépendances pour C# (.NET) — guide complet

Conteneur d'injection de dépendances pour C# (.NET) : guide complet

L'injection de dépendances (DI) est l'un des principes clés du développement moderne en C# (.NET), permettant de créer des applications faiblement couplées, testables et faciles à maintenir. Dans l'écosystème .NET, l'outil principal pour implémenter la DI est le conteneur intégré du package Microsoft.Extensions.DependencyInjection. Dans cet article, nous allons détailler ce qu'est un conteneur DI, comment le configurer, quels cycles de vie existent et comment l'utiliser correctement dans des projets réels.

Qu'est-ce qu'un conteneur d'injection de dépendances ?

Un conteneur d'injection de dépendances (ou conteneur IoC) est un composant logiciel qui gère automatiquement la création et l'injection des dépendances des objets. Au lieu de créer manuellement des objets avec new, vous enregistrez les types dans le conteneur, et celui-ci se charge de leur création et de leur liaison.

Les principaux avantages de l'utilisation d'un conteneur DI :

• Réduction du couplage du code — les classes dépendent d'abstractions (interfaces) plutôt que d'implémentations concrètes.
• Simplification des tests — il est facile de remplacer les dépendances par des objets mock.
• Gestion centralisée du cycle de vie — vous contrôlez quand les objets sont créés et détruits.
• Flexibilité accrue — vous pouvez changer les implémentations sans modifier le code des consommateurs.

Installation et configuration du conteneur DI

Dans les projets .NET modernes (ASP.NET Core, Console, Worker Services), le conteneur DI est déjà intégré. Pour l'utiliser, il suffit d'ajouter le package au projet :

dotnet add package Microsoft.Extensions.DependencyInjection

Ensuite, une instance de IServiceCollection est créée, dans laquelle toutes les dépendances sont enregistrées. Voici un exemple simple d'enregistrement de services :

using Microsoft.Extensions.DependencyInjection;

// Définir une interface et son implémentationpublic interface IMessageService{    void Send(string message);}

public class EmailService : IMessageService{    public void Send(string message)    {        Console.WriteLine($"Email envoyé : {message}");    }}

// Configuration du conteneurvar services = new ServiceCollection();services.AddTransient<IMessageService, EmailService>();

// Construction du fournisseur de servicesvar serviceProvider = services.BuildServiceProvider();

// Obtention d'une instance du servicevar messageService = serviceProvider.GetService<IMessageService>();messageService.Send("Bonjour depuis DI !");

Cycles de vie des dépendances

Le conteneur DI prend en charge trois modes principaux de gestion de la durée de vie des objets :

• Transient (AddTransient) — chaque demande crée une nouvelle instance. Convient aux services légers sans état.
• Scoped (AddScoped) — une instance par portée (par exemple, par requête HTTP dans ASP.NET Core). Idéal pour les services avec état dans le cadre d'une seule opération.
• Singleton (AddSingleton) — une instance unique pour toute l'application. Utilisé pour les caches, les journaux, les configurations.

Exemple d'enregistrement avec différents cycles de vie :

services.AddTransient<ITransientService, TransientService>();services.AddScoped<IScopedService, ScopedService>();services.AddSingleton<ISingletonService, SingletonService>();

Important : si un service dépend d'un autre service avec un cycle de vie plus court, cela peut entraîner des erreurs (par exemple, un Singleton qui utilise un Scoped). Ces situations sont appelées "dépendances captives" et doivent être évitées.

Injection de dépendances via le constructeur

La méthode d'injection la plus courante est via le constructeur. Le conteneur résout automatiquement toutes les dépendances