C# Language
स्ट्रक्चरल डिजाइन पैटर्न

परिचय

एडाप्टर डिजाइन पैटर्न

"एडेप्टर" जैसा कि नाम से पता चलता है कि वह वस्तु है जो दो परस्पर असंगत इंटरफेस को एक दूसरे के साथ संवाद करने देती है।

उदाहरण के लिए: यदि आप एक Iphone 8 (या किसी भी अन्य Apple उत्पाद) खरीदते हैं, तो आपको एडेप्टर की बहुत आवश्यकता है। क्योंकि डिफ़ॉल्ट इंटरफ़ेस ऑडियो जेक या यूएसबी का समर्थन नहीं करता है। इन एडाप्टर के साथ आप तारों के साथ इयरफ़ोन का उपयोग कर सकते हैं या आप एक सामान्य ईथरनेट केबल का उपयोग कर सकते हैं। इसलिए "दो परस्पर असंगत इंटरफेस एक दूसरे के साथ संवाद करते हैं" ।

तो तकनीकी शब्दों में इसका मतलब है: एक वर्ग के इंटरफ़ेस को दूसरे इंटरफ़ेस में परिवर्तित करें जो एक ग्राहक अपेक्षा करता है। एडॉप्टर कक्षाओं को एक साथ काम करने देता है जो असंगत इंटरफेस के कारण अन्यथा नहीं हो सकता है। इस पैटर्न में भाग लेने वाले वर्ग और वस्तुएँ हैं:

एडेप्टर पैटर्न 4 तत्वों को बाहर निकालता है

1. ITarget: यह इंटरफ़ेस है जो क्लाइंट द्वारा कार्यक्षमता को प्राप्त करने के लिए उपयोग किया जाता है।
2. Adaptee: यह कार्यक्षमता है जो ग्राहक की इच्छा है लेकिन इसका इंटरफ़ेस क्लाइंट के अनुकूल नहीं है।
3. क्लाइंट: यह वह वर्ग है जो एडेप्टरी कोड का उपयोग करके कुछ कार्यक्षमता प्राप्त करना चाहता है।
4. एडॉप्टर: यह वह वर्ग है जो ITarget को लागू करेगा और Adaptee कोड को कॉल करेगा जिसे ग्राहक कॉल करना चाहता है।

यूएमएल

पहला कोड उदाहरण (सैद्धांतिक उदाहरण) ।

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

दूसरा कोड उदाहरण (वास्तविक दुनिया की नकल)

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

कब इस्तेमाल करें

• एक प्रणाली को किसी अन्य प्रणाली के वर्गों का उपयोग करने की अनुमति दें जो इसके साथ असंगत है।
• नए और पहले से मौजूद सिस्टम के बीच संचार की अनुमति दें जो एक दूसरे से स्वतंत्र हैं
• Ado.Net SqlAdapter, OracleAdapter, MySqlAdapter एडाप्टर पैटर्न का सबसे अच्छा उदाहरण है।