C# Language
Modèles de conception structurelle

Introduction

Modèle de conception d'adaptateur

«Adapter», comme son nom l'indique, est l'objet qui permet à deux interfaces incompatibles entre elles de communiquer entre elles.

Par exemple: si vous achetez un iPhone 8 (ou tout autre produit Apple), vous avez besoin de beaucoup d’adaptateurs. Parce que l'interface par défaut ne prend pas en charge l'audio jac ou USB. Avec ces adaptateurs, vous pouvez utiliser des écouteurs avec des fils ou utiliser un câble Ethernet normal. Ainsi, "deux interfaces incompatibles entre elles communiquent entre elles" .

Donc, en termes techniques, cela signifie: Convertir l'interface d'une classe en une autre interface attendue par un client. L'adaptateur permet aux classes de fonctionner ensemble, ce qui ne pourrait pas être dû à des interfaces incompatibles. Les classes et objets participant à ce modèle sont:

Le modèle d'adaptateur sort 4 éléments

1. ITarget: C'est l'interface utilisée par le client pour atteindre les fonctionnalités.
2. Adaptee: C'est la fonctionnalité que le client souhaite mais son interface n'est pas compatible avec le client.
3. Client: il s'agit de la classe qui souhaite obtenir des fonctionnalités en utilisant le code d'adaptee.
4. Adapter: C'est la classe qui implémenterait ITarget et appellerait le code Adaptee que le client veut appeler.

UML

Premier code Exemple (exemple théorique) .

public interface ITarget
{
    void MethodA();
}

public class Adaptee
{
    public void MethodB()
    {
        Console.WriteLine("MethodB() is called");
    }
}

public class Client
{
    private ITarget target;

    public Client(ITarget target)
    {
        this.target = target;
    }

    public void MakeRequest()
    {
        target.MethodA();
    }
}  

public class Adapter : Adaptee, ITarget
{
    public void MethodA()
    {
        MethodB();
    }
}

Deuxième exemple de code (mise en œuvre du monde réel)

/// <summary>
///  Interface: This is the interface which is used by the client to achieve functionality.
/// </summary>
public interface ITarget
{
    List<string> GetEmployeeList();
}

/// <summary>
/// Adaptee: This is the functionality which the client desires but its interface is not compatible with the client.
/// </summary>
public class CompanyEmplyees
{
    public string[][] GetEmployees()
    {
        string[][] employees = new string[4][];

        employees[0] = new string[] { "100", "Deepak", "Team Leader" };
        employees[1] = new string[] { "101", "Rohit", "Developer" };
        employees[2] = new string[] { "102", "Gautam", "Developer" };
        employees[3] = new string[] { "103", "Dev", "Tester" };

        return employees;
    }
}

/// <summary>
/// Client: This is the class which wants to achieve some functionality by using the adaptee’s code (list of employees).
/// </summary>
public class ThirdPartyBillingSystem
{
    /* 
     * This class is from a thirt party and you do'n have any control over it. 
     * But it requires a Emplyee list to do its work
     */

    private ITarget employeeSource;

    public ThirdPartyBillingSystem(ITarget employeeSource)
    {
        this.employeeSource = employeeSource;
    }

    public void ShowEmployeeList()
    {
        // call the clietn list in the interface
        List<string> employee = employeeSource.GetEmployeeList();

        Console.WriteLine("######### Employee List ##########");
        foreach (var item in employee)
        {
            Console.Write(item);
        }

    }
}

/// <summary>
/// Adapter: This is the class which would implement ITarget and would call the Adaptee code which the client wants to call.
/// </summary>
public class EmployeeAdapter : CompanyEmplyees, ITarget
{
    public List<string> GetEmployeeList()
    {
        List<string> employeeList = new List<string>();
        string[][] employees = GetEmployees();
        foreach (string[] employee in employees)
        {
            employeeList.Add(employee[0]);
            employeeList.Add(",");
            employeeList.Add(employee[1]);
            employeeList.Add(",");
            employeeList.Add(employee[2]);
            employeeList.Add("\n");
        }

        return employeeList;
    }
}

/// 
/// Demo
/// 
class Programs
{
    static void Main(string[] args)
    {
        ITarget Itarget = new EmployeeAdapter();
        ThirdPartyBillingSystem client = new ThirdPartyBillingSystem(Itarget);
        client.ShowEmployeeList();
        Console.ReadKey();
    }
}

Quand utiliser

• Autoriser un système à utiliser des classes d'un autre système incompatible avec celui-ci.
• Permettre la communication entre les systèmes nouveaux et existants, indépendants les uns des autres
• Ado.Net SqlAdapter, OracleAdapter, MySqlAdapter sont le meilleur exemple de Pattern Adapter.