Commencer avec des principes solides

Principe de substitution de Liskov #

Pourquoi utiliser LSP

Scénario : Supposons que nous ayons 3 bases de données (clients hypothécaires, clients de comptes courants et clients de comptes d’épargne) qui fournissent des données client et nous avons besoin des détails du client pour le nom de famille du client donné. Maintenant, nous pouvons obtenir plus d’un détail client à partir de ces 3 bases de données par rapport au nom de famille donné.

Mise en œuvre

COUCHE DE MODÈLE COMMERCIAL :

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

COUCHE D’ACCÈS AUX DONNÉES :

public interface IDataAccess
{
    Customer GetDetails(string lastName);
}

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 DES CLIENTS HYPOTHÉCAIRES :

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

ACCÈS AUX DONNÉES CLIENT DU COMPTE ACTUEL :

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

ACCÈS AUX DONNÉES DES CLIENTS DU COMPTE D’ÉPARGNE :

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

Une fois ces 3 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 détails du client à ses clients.

COUCHE COMMERCIALE :

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 le garder 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 de la classe CustomerServiceManager n’appellera que la méthode GetCustomerDetails, transmettra lastName et ne devrait pas se soucier de la provenance et de la provenance des données.

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

Installation ou configuration #

Vous pouvez utiliser n’importe quel langage IDE et OOP pour mettre en œuvre les principes S.O.L.I.D. Dans l’exemple de code, j’ai utilisé C # car il s’agit du langage le plus utilisé dans le mot .NET et ressemble étroitement à Java et C ++.