Injection de dépendances en C# : Guide complet avec exemples

Injection de dépendances en C# : qu'est-ce que c'est et pourquoi en avoir besoin

Dependency Injection (DI) est l'un des modèles de conception clés qui permet de créer des applications faiblement couplées et facilement testables en C#. Au lieu que la classe crée elle-même ses dépendances (par exemple, des objets pour travailler avec une base de données ou la journalisation), ces dépendances sont transmises (injectées) de l'extérieur. Cela implémente le principe Inversion of Control (IoC) — le contrôle est transféré à un conteneur externe.

Dans l'écosystème .NET, DI est devenu la norme de facto à partir d'ASP.NET Core. Le conteneur de dépendances intégré (via Microsoft.Extensions.DependencyInjection) permet d'enregistrer et de résoudre facilement les dépendances. Dans cet article, nous aborderons la théorie, des exemples pratiques et les meilleures pratiques d'utilisation de DI en C#.

Principes de base de l'injection de dépendances

DI repose sur trois méthodes de base pour injecter les dépendances. Examinons chacune d'elles.

1. Injection par constructeur

La méthode la plus courante et préférée. Les dépendances sont transmises via les paramètres du constructeur de la classe.

public interface ILogger{    void Log(string message);}

public class ConsoleLogger : ILogger{    public void Log(string message) => Console.WriteLine(message);}

public class OrderService{    private readonly ILogger _logger;

    // Injection de dépendance par constructeur    public OrderService(ILogger logger)    {        _logger = logger;    }

    public void ProcessOrder(int orderId)    {        _logger.Log($"Traitement de la commande {orderId}");        // logique métier    }}

2. Injection par propriété

La dépendance est définie via une propriété publique. Moins préférable car cela rend la dépendance optionnelle et peut entraîner des erreurs lors de l'exécution.

public class OrderService{    public ILogger Logger { get; set; }

    public void ProcessOrder(int orderId)    {        if (Logger == null)            throw new InvalidOperationException("Logger non défini");        Logger.Log($"Traitement de la commande {orderId}");    }}

3. Injection par méthode

La dépendance est transmise comme paramètre de méthode. Utilisée rarement, généralement pour des dépendances temporaires.

public class OrderService{    public void ProcessOrder(int orderId, ILogger logger)    {        logger.Log($"Traitement de la commande {orderId}");    }}

Enregistrement des dépendances dans le conteneur .NET

Dans le .NET moderne (ASP.NET Core, Console, Worker Services), le conteneur DI intégré est utilisé. L'enregistrement se fait dans la méthode ConfigureServices ou lors de la création d'un ServiceCollection.

Il existe trois durées de vie (lifetime) pour les services enregistrés :

• Transient — une nouvelle instance est créée à chaque demande. Convient pour les services légers et éphémères.
• Scoped — une instance par requête HTTP (ou scope). Utilisé pour Entity Framework DbContext.
• Singleton — une instance pour toute l'application. Convient pour les caches, les configurations, les loggers.

// Exemple pour ASP.NET Corepublic class Startup{    public void ConfigureServices(IServiceCollection services)    {        // Enregistrement avec interface        services.AddTransient<ILogger, ConsoleLogger>();        services.AddScoped<IOrderRepository, OrderRepository>();        services.AddSingleton<IConfiguration, ConfigurationManager>();

        // Enregistrement sans interface (classe concrète)        services.AddTransient<OrderService>();    }}

// Utilisation dans un contrôleurpublic class OrderController : ControllerBase{    private readonly OrderService _orderService;

    public OrderController(OrderServi