solid-principles

#solid-

principles

Table des matières

À propos 1

Chapitre 1: Démarrer avec des principes solides 2

Remarques 2

Examples 2

Installation ou configuration 2

Principe de substitution de Liskov 2

Chapitre 2: Principe d'inversion de dépendance (DIP) 5

Introduction 5

Examples 5

Principe d'inversion de dépendance C # 5

Chapitre 3: Principe de responsabilité unique (SRP) 7

Introduction 7

Remarques 7

Examples 7

Principe de responsabilité unique C # 7

Principe de responsabilité unique 8

Chapitre 4: Principe de ségrégation d'interface (ISP) 13

Introduction 13

Examples 13

Principe de ségrégation d'interface C # 13

Chapitre 5: Principe Fermé Ouvert (OCP) 15

Introduction 15

Examples 15

Ouvrir le principe fermé C # 15

Crédits 17

À propos

You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: solid-principles

It is an unofficial and free solid-principles ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official solid-principles.

The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to info@zzzprojects.com

https://riptutorial.com/fr/home 1

Chapitre 1: Démarrer avec des principes solides

Remarques

Cette section fournit une vue d'ensemble de ce que sont les principes solides, et pourquoi un développeur peut vouloir l'utiliser.

Il devrait également mentionner tous les grands sujets dans les principes solides, et établir un lien avec les sujets connexes. La documentation des principes solides étant nouvelle, vous devrez peut-être créer des versions initiales de ces rubriques connexes.

Examples

Installation ou configuration

Vous pouvez utiliser n'importe quel langage IDE et OOP pour implémenter les principes SOLID . Dans l'exemple de code, j'ai utilisé C # car c'est le langage le plus utilisé dans les mots .NET et il ressemble beaucoup à Java et C ++.

Principe de substitution de Liskov

Pourquoi utiliser LSP

Scénario: Supposons que nous ayons 3 bases de données (clients hypothécaires, clients actuels et clients de compte d'épargne) qui fournissent des données sur les clients et que nous avons besoin des coordonnées du client pour le nom de famille du client. Maintenant, nous pouvons obtenir plus de 1 détail client parmi ces 3 bases de données par rapport au nom de famille donné.

la mise en oeuvre

COUCHE DE MODÈLE D'AFFAIRES:

public class Customer { // customer detail properties... }

COUCHE D'ACCÈS AUX DONNÉES:

public interface IDataAccess { Customer GetDetails(string lastName);

https://riptutorial.com/fr/home 2

}

L'interface ci-dessus est implémentée par la classe abstraite

public abstract class BaseDataAccess : IDataAccess { /// <summary> Enterprise library data block Database object. </summary> public Database Database; public Customer GetDetails(string lastName) { // use the database object to call the stored procedure to retirve the customer detials } }

Cette classe abstraite a une méthode commune "GetDetails" pour les 3 bases de données, qui est étendue par chacune des classes de base de données, comme indiqué ci-dessous.

ACCÈS AUX DONNÉES DU CLIENT HYPOTHÉCAIRE:

public class MortgageCustomerDataAccess : BaseDataAccess { public MortgageCustomerDataAccess(IDatabaseFactory factory) { this.Database = factory.GetMortgageCustomerDatabase(); } }

ACCÈS AUX DONNÉES DU COMPTE DU COMPTE COURANT:

public class CurrentAccountCustomerDataAccess : BaseDataAccess { public CurrentAccountCustomerDataAccess(IDatabaseFactory factory) { this.Database = factory.GetCurrentAccountCustomerDatabase(); } }

ACCÈS AUX DONNÉES DU COMPTE D'ÉPARGNE:

public class SavingsAccountCustomerDataAccess : BaseDataAccess { public SavingsAccountCustomerDataAccess(IDatabaseFactory factory) { this.Database = factory.GetSavingsAccountCustomerDatabase(); } }

Une fois ces trois classes d'accès aux données définies, nous attirons maintenant notre attention sur le client. Dans la couche Business, nous avons la classe CustomerServiceManager qui renvoie les informations client à ses clients.

COUCHE D'AFFAIRES:

https://riptutorial.com/fr/home 3

public class CustomerServiceManager : ICustomerServiceManager, BaseServiceManager { public IEnumerable<Customer> GetCustomerDetails(string lastName) { IEnumerable<IDataAccess> dataAccess = new List<IDataAccess>() { new MortgageCustomerDataAccess(new DatabaseFactory()), new CurrentAccountCustomerDataAccess(new DatabaseFactory()), new SavingsAccountCustomerDataAccess(new DatabaseFactory()) }; IList<Customer> customers = new List<Customer>(); foreach (IDataAccess nextDataAccess in dataAccess) { Customer customerDetail = nextDataAccess.GetDetails(lastName); customers.Add(customerDetail); } return customers; } }

Je n'ai pas montré l'injection de dépendance pour que cela reste simple car cela devient déjà compliqué maintenant.

Maintenant, si nous avons une nouvelle base de données de détails sur les clients, nous pouvons simplement ajouter une nouvelle classe qui étend BaseDataAccess et fournit son objet de base de données.

Bien sûr, nous avons besoin de procédures stockées identiques dans toutes les bases de données participantes.

Enfin, le client CustomerServiceManagerclass appelle uniquement la méthode GetCustomerDetails, transmet le nom de famille et ne se soucie pas de la provenance et de la provenance des données.

J'espère que cela vous donnera une approche pratique pour comprendre LSP.

Lire Démarrer avec des principes solides en ligne: https://riptutorial.com/fr/solid-principles/topic/9700/demarrer-avec-des-principes-solides

https://riptutorial.com/fr/home 4

Chapitre 2: Principe d'inversion de dépendance (DIP)

Introduction

Le principe dit fondamentalement, la Class devrait dépendre des abstractions (par exemple, interface, classes abstraites), pas des détails spécifiques (implémentations). Cela signifie que vous devriez laisser l'appelant créer les dépendances au lieu de laisser la classe elle-même créer les dépendances.

Examples

Principe d'inversion de dépendance C #

Pour comprendre le principe d'inversion de dépendance (DIP), nous devons clarifier le concept d'

https://riptutorial.com/fr/home 5

inversion de contrôle (IOC) et d' injection de dépendance (DI) . Donc, ici, nous discutons tout sur les termes avec le principe d'inversion de dépendance (DIP) .

Inversion du contrôle (IOC) : le contrôle ou la logique qui ne fait pas partie de cette entité est pris en charge par quelqu'un d'autre. Ou, IOC est une technique de programmation où le LOGIC non concerné est délégué à une autre entité.

Injection de dépendance (DI) : L'injection de dépendance est une technique qui permet d'injecter des objets dépendants d'une classe, ce qui rend l'architecture plus faiblement couplée.

Il existe de nombreux conteneurs IOC pour le framework .NET qui nous aident à résoudre les dépendances. Certains sont listés ici .

Lire Principe d'inversion de dépendance (DIP) en ligne: https://riptutorial.com/fr/solid-principles/topic/9730/principe-d-inversion-de-dependance--dip-

https://riptutorial.com/fr/home 6

Chapitre 3: Principe de responsabilité unique (SRP)

Introduction

Il ne devrait jamais y avoir plus d'une raison de changement dans les entités logicielles (classe, fonction, fichier, etc.). Une classe, une fonction, un fichier, etc. ne devrait avoir qu'une seule raison de changer.

Remarques

Juste parce que vous le pouvez, ne signifie pas que vous devriez.

Examples

Principe de responsabilité unique C #

Voyons d'abord le problème. Regardez le code ci-dessous:

public class BankAccount { public BankAccount() {} public string AccountNumber { get; set; } public decimal AccountBalance { get; set; } public decimal CalculateInterest() { // Code to calculate Interest } }

Ici, la classe BankAccount contient les propriétés du compte et calcule également les intérêts du compte. Maintenant, regardez les quelques demandes de changement que nous avons reçues de la part de l’entreprise:

Veuillez ajouter une nouvelle propriété AccountHolderName .1. Une nouvelle règle a été introduite pour calculer les intérêts.2.

Ce type de demande de changement est totalement différent. On change de caractéristiques; où comme autre impact sur la fonctionnalité. Nous avons deux types de raisons différentes pour changer une classe. Cela viole le principe de la responsabilité unique.

Essayons maintenant d'implémenter SRP pour résoudre cette violation. Regardez le code ci-dessous:

https://riptutorial.com/fr/home 7

public interface IBankAccount { string AccountNumber { get; set; } decimal AccountBalance { get; set; } } public interface IInterstCalculator { decimal CalculateInterest(); } public class BankAccount : IBankAccount { public string AccountNumber { get; set; } public decimal AccountBalance { get; set; } } public class InterstCalculator : IInterstCalculator { public decimal CalculateInterest(IBankAccount account) { // Write your logic here return 1000; } }

Maintenant, notre classe BankAccount est juste responsable des propriétés du compte bancaire. Si vous souhaitez ajouter une nouvelle règle métier pour le calcul de l'intérêt , il n'est pas nécessaire de modifier la classe BankAccount .

De plus, la classe InterestCalculator ne nécessite aucune modification, au cas où nous devions ajouter une nouvelle propriété AccountHolderName . Donc, c'est la mise en œuvre du principe de la responsabilité unique .

Nous avons également utilisé des interfaces pour communiquer entre InterestCalculator et la classe BankAccount . Cela nous aidera à gérer les dépendances entre les classes.

Principe de responsabilité unique

introduction

SRP peut être défini comme «une classe ne gère qu’une seule responsabilité». C'est une définition très courte de quelque chose qui influence les autres principes de SOLID. Je crois que si nous réussissons, cela aura des répercussions positives sur les principes à venir, alors commençons! Exemple pratique Disons que nous avons une boutique en ligne où les gens peuvent commander des articles ou des produits et dans la base de code, nous avons une classe OrderProcessor qui traite les nouvelles commandes lorsque les utilisateurs cliquent sur le bouton Payer maintenant.

La raison OrderProcessor laquelle OrderProcessor est écrit est d'effectuer les tâches suivantes, en d'autres termes, la classe OrderProcessor a les responsabilités suivantes:

Vérifiez que la carte de crédit a été acceptée - finance1.

https://riptutorial.com/fr/home 8

Vérifiez que l'argent a été facturé - finance2. Vérifiez que l'article est en stock - inventaire3. Demander l'article pour la réservation4. Obtenir le délai de livraison estimé5. Envoyer la confirmation par email au client6.

Voici la définition de la classe OrderProcessor

public class OrderProcessor { public bool ProcessOrder(Order orderToProcess) { // 1) Check the credit card has been accepted. int creditCardId = orderToProcess.CreditCardId; CreditCard creditCardDetails = new CreditCard(); using (SqlConnection connect = new SqlConnection()) { using (SqlCommand command = new SqlCommand()) { command.Connection = connect; command.CommandText = "<schema>.<spName>"; command.CommandType = CommandType.StoredProcedure; SqlParameter idParam = new SqlParameter(); idParam.Direction = ParameterDirection.Input; idParam.Value = creditCardId; idParam.ParameterName = "@Id"; idParam.DbType = DbType.Int32; command.Parameters.Add(idParam); using (SqlDataReader reader = command.ExecuteReader()) { while (reader.Read()) { creditCardDetails.CardId = int.Parse(reader["Id"].ToString()); creditCardDetails.CardLongNumber = reader["CardLongNumber"].ToString(); creditCardDetails.CvcNumber = int.Parse(reader["CvcNumber"].ToString()); creditCardDetails.ExpiryDate = DateTime.Parse(reader["ExpiryDate"].ToString()); creditCardDetails.NameOnTheCard = reader["NameOnTheCard"].ToString(); creditCardDetails.StartDate = DateTime.Parse(reader["StartDate"].ToString()); } } } } // charge the total amount using the credit card details.. decimal amountToCharge = orderToProcess.OrderTotal; using (WebClient webClient = new WebClient()) { string response = webClient.DownloadString($"https://CreditCardProcessor/api/ProcessesPayments?amount={amountToCharge}&CreditCard={creditCardDetails}"); // processes response: check if its been successful or failure then proceed

https://riptutorial.com/fr/home 9

further.... } // check the item is in the stock Dictionary<int, bool> productAvailability = new Dictionary<int, bool>(); foreach (int productId in orderToProcess.ProductIds) { using (SqlConnection connection = new SqlConnection()) { using (SqlCommand command = new SqlCommand()) { command.Connection = connection; command.CommandText = "<schema>.<spName>"; command.CommandType = CommandType.StoredProcedure; SqlParameter idParam = new SqlParameter(); idParam.Direction = ParameterDirection.Input; idParam.Value = productId; idParam.ParameterName = "@Id"; idParam.DbType = DbType.Int32; command.Parameters.Add(idParam); object resultObject = command.ExecuteScalar(); bool prductAvailable = bool.Parse(resultObject.ToString()); if (prductAvailable) productAvailability.Add(productId, true); } } } // request item for reservation ReservationServiceClientProxy client = new ReservationServiceClientProxy(); foreach (KeyValuePair<int, bool> nextProduct in productAvailability) { ReservationRequest requst = new ReservationRequest() { ProductId = nextProduct.Key }; ReservationResponse response = client.ReserveProduct(requst); } // calculate estimated time of delivery... DeliveryService ds = new DeliveryService(); int totalMinutes = 0; foreach (KeyValuePair<int, bool> nextProduct in productAvailability) { totalMinutes += ds.EstimateDeliveryTimeInMinutes(nextProduct.Key); } // email customer int customerId = orderToProcess.CustomerId; string customerEmail = string.Empty; using (SqlConnection connection = new SqlConnection())

https://riptutorial.com/fr/home 10

{ using (SqlCommand command = new SqlCommand()) { command.Connection = connection; command.CommandText = "<schema>.<spName>"; command.CommandType = CommandType.StoredProcedure; SqlParameter idParam = new SqlParameter(); idParam.Direction = ParameterDirection.Input; idParam.Value = customerId; idParam.ParameterName = "@customerId"; idParam.DbType = DbType.Int32; command.Parameters.Add(idParam); object resultObject = command.ExecuteScalar(); customerEmail = resultObject.ToString(); } } MailMessage message = new MailMessage(new MailAddress("Some.One@SuperCheapStore.co.uk"), new MailAddress(customerEmail)); message.Body = $"You item has been dispatched and will be delivered in {totalMinutes / 1440} days"; message.Subject = "Your order update!"; SmtpClient smtpClient = new SmtpClient("HostName/IPAddress"); smtpClient.Send(message); return true; } }

Comme nous pouvons le voir dans la définition de classe, OrderProcessor a pris plus d’une responsabilité. Portons notre attention sur la version 2 de la classe OrderProcesser écrite en gardant à l'esprit SRP.

public class OrderProcessorV2 { public bool ProcessOrder(Order orderToProcess) { // 1) Check the credit card has been accepted. CreditCardDataAccess creditCardAccess = new CreditCardDataAccess(); CreditCard cardDetails = creditCardAccess.GetCreditCardDetails(orderToProcess.CreditCardId); // 2) Check the money has been charged – finance PaymentProcessor paymentProcessor = new PaymentProcessor(); paymentProcessor.DebitAmount(orderToProcess.OrderTotal, cardDetails); // 3) Check the item is in stock – inventory InventoryService inventory = new InventoryService(); Dictionary<int, bool> productAvailability = inventory.CheckStockAvailability(orderToProcess.ProductIds); foreach (int nextProductId in orderToProcess.ProductIds) {

https://riptutorial.com/fr/home 11

inventory.CheckStockAvailability(nextProductId); } // 4) Request the item for reservation ReservationService reservation = new ReservationService(); foreach (int nextProductId in orderToProcess.ProductIds) { reservation.ReserveProduct(nextProductId); } // 5) Get the estimated delivery time // calculate estimated time of delivery... DeliveryService ds = new DeliveryService(); int totalMinutes = 0; foreach (KeyValuePair<int, bool> nextProduct in productAvailability) { totalMinutes += ds.EstimateDeliveryTimeInMinutes(nextProduct.Key); } // 6) Email the confirmation to the customer CustomerDataAccess customerDataAccess = new CustomerDataAccess(); Customer cust = customerDataAccess.GetCustomerDetails(orderToProcess.CustomerId); EmailService mailService = new EmailService(); mailService.NotifyCustomer(cust.Email); // if everything step is successful then return true.. } }

La quantité de lignes de code dans OrderProcessorV2 a radicalement changé, de même que la lisibilité. La responsabilité globale de OrderProcessorV2 peut être comprise dans le temps nécessaire pour lire cette ligne. Cela se traduit par une productivité accrue.

Lire Principe de responsabilité unique (SRP) en ligne: https://riptutorial.com/fr/solid-principles/topic/9726/principe-de-responsabilite-unique--srp-

https://riptutorial.com/fr/home 12

Chapitre 4: Principe de ségrégation d'interface (ISP)

Introduction

Le principe stipule qu'aucun client ne devrait être obligé de dépendre de méthodes qu'il n'utilise pas. Un client ne devrait jamais être obligé d'implémenter une interface qu'il n'utilise pas ou que le client ne devrait pas être contraint de dépendre de méthodes qu'il n'utilise pas.

Examples

Principe de ségrégation d'interface C #

Ici, nous donnons un exemple de violation de FAI , puis nous refactorisons cette violation. Sans parler de choses inutiles, sautons dans le code.

Violation de FAI:

public interface IMessage{ IList<string> ToAddress {get; set;} IList<string> BccAddresses {get; set;} string MessageBody {get; set;} string Subject {get; set;} bool Send(); } public class SmtpMessage : IMessage{ public IList<string> ToAddress {get; set;} public IList<string> BccAddresses {get; set;} public string MessageBody {get; set;} public string Subject {get; set;} public bool Send(){ // Code for sending E-mail. } } public class SmsMessage : IMessage{ public IList<string> ToAddress {get; set;} public IList<string> BccAddresses { get { throw new NonImplementedException(); } set { throw new NonImplementedException(); } } public string MessageBody {get; set;} public string Subject { get { throw new NonImplementedException(); } set { throw new NonImplementedException(); } } public bool Send(){ // Code for sending SMS. } }

https://riptutorial.com/fr/home 13

Dans SmsMessage, nous n'avons pas besoin de BccAddresses et de Subject , mais nous avons dû l'implémenter à cause de l'interface IMessage . Donc, cela viole le principe du fournisseur de services Internet.

Supprimer la violation selon ISP :

public interface IMessage{ bool Send(IList<string> toAddress, string messageBody); } public interface IEmailMessage : IMessage{ string Subject {get; set;} IList<string> BccAddresses {get; set;} } public class SmtpMessage : IEmailMessage{ public IList<string> BccAddresses {get; set;} public string Subject {get; set;} public bool Send (IList<string> toAddress, string messageBody){ // Code for sending E-mail. } } public class SmsMessage : IMessage{ public bool Send (IList<string> toAddress, string messageBody){ // Code for sending SMS. } }

SmsMessage ne nécessite que toAddress et messageBody , nous pouvons donc maintenant utiliser l'interface IMessage pour éviter les implémentations inutiles.

Lire Principe de ségrégation d'interface (ISP) en ligne: https://riptutorial.com/fr/solid-principles/topic/9731/principe-de-segregation-d-interface--isp-

https://riptutorial.com/fr/home 14

Chapitre 5: Principe Fermé Ouvert (OCP)

Introduction

Les entités logicielles (classe, modules, fonctions, etc.) doivent être ouvertes pour extension mais fermées pour modification.

Examples

Ouvrir le principe fermé C #

Ici, nous essayons d'expliquer OCP en utilisant codebase. Nous allons d'abord montrer un scénario qui viole l'OCP et ensuite nous supprimerons cette violation.

Calcul de zone (code de violation OCP):

public class Rectangle{ public double Width {get; set;} public double Height {get; set;} } public class Circle{ public double Radious {get; set;} } public double getArea (object[] shapes){ double totalArea = 0; foreach(var shape in shapes){ if(shape is Rectangle){ Rectangle rectangle = (Rectangle)shape; totalArea += rectangle.Width * rectangle.Height; } else{ Circle circle = (Circle)shape; totalArea += circle.Radious * circle.Radious * Math.PI; } } }

Maintenant, si nous avons besoin de calculer un autre type d'objet (par exemple, Trapezium), nous devons ajouter une autre condition. Mais d'après les règles d'OCP, nous savons que les entités logicielles doivent être fermées pour modification . Donc, cela viole l'OCP.

D'accord. Essayons de résoudre cette violation mettant en œuvre OCP.

public abstract class shape{ public abstract double Area(); } public class Rectangle : shape{

https://riptutorial.com/fr/home 15

public double Width {get; set;} public double Height {get; set;} public override double Area(){ return Width * Height; } } public class Circle : shape{ public double Radious {get; set;} public override double Area(){ return Radious * Radious * Math.PI; } } public double getArea (shape[] shapes){ double totalArea = 0; foreach(var shape in shapes){ totalArea += shape.Area(); } return totalArea; }

Maintenant, si nous avons besoin de calculer un autre type d'objet, nous n'avons pas besoin de changer de logique (dans getArea ()), nous avons juste besoin d'ajouter une autre classe comme Rectangle ou Circle .

Lire Principe Fermé Ouvert (OCP) en ligne: https://riptutorial.com/fr/solid-principles/topic/9727/principe-ferme-ouvert--ocp-

https://riptutorial.com/fr/home 16

Crédits

S. No

Chapitres Contributeurs

1Démarrer avec des principes solides

Community, Yawar Murtaza

2Principe d'inversion de dépendance (DIP)

Arif

3Principe de responsabilité unique (SRP)

Arif, Yawar Murtaza

4Principe de ségrégation d'interface (ISP)

Arif

5Principe Fermé Ouvert (OCP)

Arif

https://riptutorial.com/fr/home 17