Injection de dépendances en C# : guide simple pour débutants

Injection de dépendances en C# : guide simple pour débutants

L'injection de dépendances (DI) est l'un des patrons de conception clés dans le développement moderne en C# et .NET. Si vous débutez tout juste votre parcours en programmation, le terme peut sembler complexe, mais en réalité, c'est beaucoup plus simple. Dans cet article, nous allons voir ce qu'est l'injection de dépendances, pourquoi elle est nécessaire et comment l'utiliser en pratique.

Qu'est-ce que l'injection de dépendances en termes simples ?

Imaginez que vous assemblez un ordinateur. Vous pouvez acheter une unité centrale prête à l'emploi, où tout est soudé et non remplaçable. Ou vous pouvez l'assembler à partir de composants individuels : processeur, carte graphique, mémoire vive. La deuxième approche est beaucoup plus flexible – vous pouvez facilement remplacer la carte graphique par une plus puissante ou ajouter une barrette de mémoire supplémentaire.

L'injection de dépendances fonctionne sur le même principe. Au lieu de "souder" rigidement les dépendances à l'intérieur d'une classe (créer des objets directement dans le code), vous les "injectez" de l'extérieur. Cela rend votre code flexible, testable et facile à maintenir.

Prenons un mauvais exemple sans DI :

public class EmailService{    private SmtpClient _client;        public EmailService()    {        // Couplage fort – la classe crée elle-même la dépendance        _client = new SmtpClient("smtp.example.com", 587);    }        public void Send(string to, string message)    {        _client.Send(to, message);    }}

Maintenant, le même exemple avec l'utilisation de DI :

public class EmailService{    private readonly ISmtpClient _client;        // La dépendance est injectée via le constructeur    public EmailService(ISmtpClient client)    {        _client = client;    }        public void Send(string to, string message)    {        _client.Send(to, message);    }}

La différence est évidente : dans le second cas, nous travaillons via l'interface ISmtpClient, et l'implémentation concrète est fournie de l'extérieur.

Les principales méthodes d'injection de dépendances en C#

En C#, il existe trois méthodes principales pour implémenter la DI. Examinons chacune d'elles.

1. Injection par constructeur

C'est la méthode la plus courante et recommandée. Les dépendances sont transmises via les paramètres du constructeur et stockées dans des champs privés.

public class OrderService{    private readonly IEmailService _emailService;    private readonly ILogger _logger;        public OrderService(IEmailService emailService, ILogger logger)    {        _emailService = emailService;        _logger = logger;    }        public void ProcessOrder(Order order)    {        _logger.Log("Traitement de la commande commencé");        _emailService.Send(order.CustomerEmail, "Votre commande a été acceptée");        _logger.Log("Traitement de la commande terminé");    }}

2. Injection par propriété

La dépendance est définie via une propriété publique. Cette méthode est pratique lorsque la dépendance est optionnelle.

public class ReportGenerator{    public ILogger Logger { get; set; }        public void GenerateReport()    {        Logger?.Log("Génération du rapport...");        // Logique de génération    }}

3. Injection par méthode

La dépendance est transmise directement à la méthode où elle est nécessaire. Généralement peu utilisée, mais peut être utile dans certains scénarios.

public class DataProcessor{    public void ProcessData(string data, IValidator validator)    {        if (validator.Validate(data))        {            // Traitement des données        }    }}

Exemple pratique : du mauvais au bon code

Voyons comment la DI peut améliorer un code réel. Supposons que nous ayons une classe pour travailler avec une base de données.

Mauvais code (sans DI) :

public class UserRepository{    private SqlConnect