Design pattern: Dependency Injection

Le design pattern Dependency Injection (DI) est une technique de conception dans laquelle les dépendances d'un objet sont injectées plutôt que créées à l'intérieur de cet objet. L'objectif est de rendre un objet indépendant des détails de l'implémentation de ses dépendances, ce qui améliore la modularité, la testabilité et la réutilisabilité du code.

En C#, l'injection de dépendances est souvent mise en œuvre en utilisant des frameworks d'injection de dépendances tels que ASP.NET Core DI, Ninject, Unity, etc., ou même manuellement en passant les dépendances via les constructeurs, propriétés ou méthodes.

Voici un exemple simple d'injection de dépendances en C# sans utiliser de framework externe :

```csharp

using System;

// Interface représentant une dépendance

public interface ILogger

{

void Log(string message);

}

// Implémentation concrète de la dépendance

public class ConsoleLogger : ILogger

{

public void Log(string message)

{

Console.WriteLine($"[Console Logger] {message}");

}

}

// Classe utilisant l'injection de dépendances

public class OrderProcessor

{

private readonly ILogger logger;

// Injection de dépendance via le constructeur

public OrderProcessor(ILogger logger)

{

this.logger = logger;

}

public void ProcessOrder(string orderInfo)

{

// Logique métier de traitement de la commande

logger.Log($"Processing order: {orderInfo}");

}

}

class Program

{

static void Main()

{

// Configuration et injection des dépendances manuellement

ILogger consoleLogger = new ConsoleLogger();

OrderProcessor orderProcessor = new OrderProcessor(consoleLogger);

// Utilisation de la classe avec les dépendances injectées

orderProcessor.ProcessOrder("12345");

}

}

```

Dans cet exemple, `OrderProcessor` dépend de `ILogger`, mais au lieu de créer directement une instance de `ConsoleLogger` à l'intérieur de `OrderProcessor`, nous passons l'instance requise via le constructeur. Cela permet de remplacer facilement l'implémentation de `ILogger` sans modifier `OrderProcessor`, ce qui rend le code plus souple et facile à tester.