C# Language
Structurele ontwerppatronen

Invoering

Adapter ontwerppatroon

"Adapter" zoals de naam al doet vermoeden is het object waarmee twee onderling onverenigbare interfaces met elkaar kunnen communiceren.

Bijvoorbeeld: als u een iPhone 8 (of een ander Apple-product) koopt, hebt u veel adapters nodig. Omdat de standaardinterface geen audio-jac of USB ondersteunt. Met deze adapters kunt u oortelefoons met draden gebruiken of u kunt een normale Ethernet-kabel gebruiken. Dus "twee onderling onverenigbare interfaces communiceren met elkaar" .

In technische termen betekent dit dus: converteer de interface van een klasse naar een andere interface die een klant verwacht. Adapter laat klassen samenwerken die anders niet konden vanwege incompatibele interfaces. De klassen en objecten die deelnemen aan dit patroon zijn:

Het adapterpatroon verlaat 4 elementen

1. ITarget: dit is de interface die door de client wordt gebruikt om functionaliteit te bereiken.
2. Adaptee: dit is de functionaliteit die de client wenst, maar de interface is niet compatibel met de client.
3. Client: Dit is de klasse die wat functionaliteit wil bereiken door de code van de adaptee te gebruiken.
4. Adapter: dit is de klasse die ITarget zou implementeren en de Adaptee-code zou aanroepen die de client wil bellen.

UML

Eerste code Voorbeeld (theoretisch voorbeeld) .

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();
    }
}

Tweede codevoorbeeld (real world imlementation)

/// <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();
    }
}

Wanneer te gebruiken

• Sta een systeem toe klassen van een ander systeem te gebruiken dat daarmee niet compatibel is.
• Sta communicatie toe tussen nieuw en reeds bestaand systeem die onafhankelijk van elkaar zijn
• Ado.Net SqlAdapter, OracleAdapter, MySqlAdapter zijn het beste voorbeeld van adapterpatroon.