Pouvez-vous expliquer le principe de substitution de Liskov avec un bon exemple de C#?

LSP une Approche Pratique

partout où je regarde les exemples de C# de LSP, les gens ont utilisé des classes et des interfaces imaginaires. Voici la mise en œuvre pratique de LSP que j'ai implémentée dans l'un de nos systèmes.

scénario: supposons que nous ayons trois bases de données (clients hypothécaires, clients des comptes courants et clients des comptes D'épargne) qui fournissent des données sur les clients et nous avons besoin de données sur les clients pour le nom de famille de chaque client. Maintenant nous pouvons obtenir plus plus de 1 détail client de ces 3 bases de données contre un nom de famille donné.

mise en œuvre:

BUSINESS MODEL LAYER:

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

COUCHE D'ACCÈS AUX DONNÉES:

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

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 retrieve the customer details
    }
}

cette classe abstraite a une méthode commune "GetDetails" pour les 3 bases de données qui est étendu par chacune des classes de la 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 DES CLIENTS DES COMPTES COURANTS:

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

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

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 D'affaires, nous avons CustomerServiceManager classe qui renvoie les détails du client à ses clients.

BUSINESS LAYER:

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 comme il se complique déjà maintenant.

maintenant, si nous avons une nouvelle base de données client, nous pouvons juste 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, passera le nom lastName et ne se souciera pas de la provenance des données.

espérons que cela vous donnera une approche pratique pour comprendre LSP.

voici le code pour appliquer le principe de Liskov.

public abstract class Fruit
{
    public abstract string GetColor();
}

public class Orange : Fruit
{
    public override string GetColor()
    {
        return "Orange Color";
    }
}

public class Apple : Fruit
{
    public override string GetColor()
    {
        return "Red color";
    }
}

class Program
{
    static void Main(string[] args)
    {
        Fruit fruit = new Orange();

        Console.WriteLine(fruit.GetColor());

        fruit = new Apple();

        Console.WriteLine(fruit.GetColor());
    }
}

: "Les classes dérivées doivent être substituables à leurs classes de base (ou interfaces)" & "Les méthodes qui utilisent des références à des classes de base (ou à des interfaces) doivent pouvoir utiliser des méthodes des classes dérivées sans en connaître les détails."