Quelles approches sont utilisées pour respecter le principe d'inversion des dépendances?

Le principe d'inversion des dépendances (Dependency Inversion Principle, DIP) stipule que :

• Les modules de haut niveau ne doivent pas dépendre directement des modules de bas niveau.
• Les deux types de modules doivent dépendre d'abstractions (par exemple, des interfaces).
• Les abstractions ne doivent pas dépendre des détails, ce sont les détails qui doivent dépendre des abstractions.

Pour respecter ce principe en C#, on applique les approches suivantes :

1. Utilisation d'interfaces et de classes abstraites

   • Les dépendances sont déclarées via des interfaces, pas des implémentations concrètes.

2. Injection de dépendances (Dependency Injection, DI)

   • Les dépendances sont passées à la classe depuis l'extérieur (via le constructeur, des propriétés ou des méthodes), et non créées à l'intérieur.
   • Cela facilite le remplacement des implémentations et simplifie les tests.

3. Inversion de contrôle (Inversion of Control, IoC)

   • Le contrôle de la création et de la liaison des objets est transféré à un conteneur ou framework externe.

4. Utilisation de conteneurs DI

   • Par exemple, Microsoft.Extensions.DependencyInjection, Autofac, Ninject, etc.
   • Ils gèrent le cycle de vie et la résolution des dépendances.

Exemple d'injection de dépendances via le constructeur :

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

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

public class UserService
{
    private readonly ILogger _logger;

    public UserService(ILogger logger)
    {
        _logger = logger;
    }

    public void CreateUser(string name)
    {
        // logique de création d'utilisateur
        _logger.Log($"Utilisateur {name} créé.");
    }
}

Dans cet exemple, UserService dépend de l'abstraction ILogger, et l'implémentation concrète ConsoleLogger est passée de l'extérieur, ce qui respecte le principe d'inversion des dépendances.