Principes SOLID en C# : théorie et pratique avec exemples

Principes SOLID en C# : théorie et pratique

SOLID est un acronyme de cinq principes fondamentaux de programmation orientée objet et de conception, formulés par Robert Martin (Oncle Bob). Ces principes aident les développeurs à créer un code flexible, maintenable et évolutif. Dans cet article, nous allons décomposer chaque principe SOLID en langage C# avec des exemples de code concrets.

1. Single Responsibility Principle (SRP) — Principe de responsabilité unique

Théorie : Chaque classe ne doit avoir qu'une seule raison de changer. En d'autres termes, une classe doit être responsable d'une tâche clairement définie.

Pratique en C# : Considérons un exemple de violation du SRP et sa correction.

Violation du SRP :

public class OrderService{    public void CreateOrder(Order order)    {        // Logique de création de commande        Console.WriteLine("Commande créée");                // Logique d'envoi d'email        SendEmail("order@example.com", "Nouvelle commande");                // Logique de journalisation        File.WriteAllText("log.txt", "Commande créée");    }}

La classe OrderService est responsable de trois tâches différentes : création de commande, envoi d'email et journalisation. Cela viole le SRP.

Correction avec respect du SRP :

public class OrderService{    private readonly IEmailService _emailService;    private readonly ILogger _logger;        public OrderService(IEmailService emailService, ILogger logger)    {        _emailService = emailService;        _logger = logger;    }        public void CreateOrder(Order order)    {        // Logique de création de commande        Console.WriteLine("Commande créée");                _emailService.SendEmail("order@example.com", "Nouvelle commande");        _logger.Log("Commande créée");    }}

public interface IEmailService{    void SendEmail(string to, string message);}

public class EmailService : IEmailService{    public void SendEmail(string to, string message)    {        Console.WriteLine($"Email envoyé à {to}");    }}

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

public class FileLogger : ILogger{    public void Log(string message)    {        File.WriteAllText("log.txt", message);    }}

Maintenant, chaque classe est responsable de sa propre tâche : OrderService — de la gestion des commandes, EmailService — de l'envoi des emails, FileLogger — de la journalisation.

2. Open-Closed Principle (OCP) — Principe d'ouverture/fermeture

Théorie : Les entités logicielles (classes, modules, fonctions) doivent être ouvertes à l'extension, mais fermées à la modification.

Pratique en C# : Utilisons l'héritage et les interfaces pour étendre les fonctionnalités sans modifier le code existant.

Violation du OCP :

public class PaymentProcessor{    public void ProcessPayment(string paymentType, decimal amount)    {        if (paymentType == "CreditCard")        {            // Traitement de carte de crédit        }        else if (paymentType == "PayPal")        {            // Traitement PayPal        }        // L'ajout d'un nouveau type nécessite la modification de la classe    }}

Correction avec respect du OCP :

public interface IPaymentMethod{    void Process(decimal amount);}

public class CreditCardPayment : IPaymentMethod{    public void Process(decimal amount)    {        Console.WriteLine($"Traitement de carte de crédit : {amount}");    }}

public class PayPalPayment : IPaymentMethod{    public void Process(decimal amount)    {        Console.WriteLine($"Traitement PayPal : {amount}");    }}

public class PaymentProcessor{    public void ProcessPayment(IPaymentMethod paymentMethod, decimal amount)    {        paymen