केवल आदिम प्रकार/प्रतिनिधियों का उपयोग करके ढीली युग्मन

मेरे पास ढीले युग्मन और इंटरफेस के बारे में एक वैचारिक/सैद्धांतिक प्रश्न है।

तो एक इंटरफ़ेस का उपयोग करने का एक तरीका एक निश्चित कन्स्ट्रक्टर द्वारा आवश्यक पैरामीटर को समाहित करना हो सकता है:

class Foo
{
    public Foo(IFooInterface foo)
    {
       // do stuff that depends on the members of IFooInterface
    }
}

तो जब तक वस्तु अनुबंध को लागू करती है, तब तक सब कुछ काम करेगा। मेरी समझ से यहां मुख्य लाभ यह है कि यह बहुरूपता को सक्षम बनाता है, लेकिन मुझे यकीन नहीं है कि इसका वास्तव में ढीले युग्मन से कोई लेना-देना है या नहीं।

आइए तर्क के लिए कहें कि एक IFooInterface इस प्रकार है:

interface IFooInterface
{
   string FooString { get; set; }
   int FooInt { get; set; }

   void DoFoo(string _str); 
}

एक ढीले युग्मन दृष्टिकोण से, उपरोक्त कन्स्ट्रक्टर में IFooInterface का उपयोग न करना बेहतर नहीं होगा, और इसके बजाय फू को इस तरह सेट अप करें:

class Foo
{
    public Foo(string _fooString, int _fooInt, Action<string> _doFoo)
    {
       // do the same operations
    }
}

क्योंकि कहें कि मैं फू की कार्यक्षमता को किसी अन्य प्रोजेक्ट में छोड़ना चाहता हूं। इसका मतलब है कि अन्य प्रोजेक्ट को भी IFooInterface को संदर्भित करना होगा, एक और निर्भरता जोड़ना। लेकिन इस तरह मैं फू को किसी अन्य प्रोजेक्ट में छोड़ सकता हूं और यह वही व्यक्त करता है जो इसे काम करने के लिए आवश्यक है। जाहिर है, मैं सिर्फ ओवरलोडेड कंस्ट्रक्टर्स का उपयोग कर सकता हूं, लेकिन तर्क के लिए कह सकता हूं कि मैं फू के कंस्ट्रक्टर्स को संशोधित नहीं करना चाहता और/या नहीं कर सकता।

सबसे महत्वपूर्ण पहलू (मेरे लिए कम से कम) यह है कि यदि आपके पास आदिम मापदंडों के एक समूह के साथ एक विधि है तो यह बदसूरत और पढ़ने में कठिन हो जाता है। तो मेरे पास एक प्रकार का रैपिंग फ़ंक्शन बनाने का विचार था जो आपको अभी भी सभी आदिम प्रकारों के बजाय इंटरफ़ेस में पास करने की अनुमति देता है:

    public static Func<T, R> Wrap<T, R>(Func<T, object[]> conversion)
    {
        return new Func<T, R>(t =>
        {
            object[] parameters = conversion(t);

            Type[] args = new Type[parameters.Length];

            for (int i = 0; i < parameters.Length; i++)
            {
                args[i] = parameters[i].GetType();
            }

            ConstructorInfo info = typeof(R).GetConstructor(args);

            return (R)info.Invoke(parameters);
        });
    }

यहां विचार यह है कि मैं एक ऐसा फ़ंक्शन वापस प्राप्त कर सकता हूं जो कुछ इंटरफ़ेस का उदाहरण लेता है जो फू की आवश्यकताओं के अनुरूप है, लेकिन फू सचमुच उस इंटरफ़ेस के बारे में कुछ भी नहीं जानता है। इसे इस तरह इस्तेमाल किया जा सकता है:

public Foo MakeFoo(IFooInterface foo)
{
    return Wrap<IFooInterface, Foo>(f => 
       new object[] { f.FooString, f.FooInt, f.DoFoo })(foo);  
}

मैंने इस बारे में चर्चा सुनी है कि इंटरफेस को ढीले-युग्मन को सक्षम करने के लिए कैसे माना जाता है, लेकिन इस बारे में सोच रहा था।

आश्चर्य है कि कुछ अनुभवी प्रोग्रामर क्या सोचते हैं।