जेनेरिक प्रकार के साथ इंटरफेस को कार्यान्वित करना जो कि किसी विधि की तुलना में कम बाधित है, मुझे

Question

पर कॉल करने की आवश्यकता है। मैं माइक्रोसॉफ्ट यूनिटी का उपयोग करने वाले ढांचे में कस्टम व्यापार तर्क को इंजेक्ट करने के लिए एक इंटरफ़ेस कार्यान्वित कर रहा हूं। मेरे मुख्य मुद्दा एक अंतरफलक मैं लागू करने की आवश्यकता को परिभाषित करता है जो निम्न विधि है:

T InterfaceMethod<T>(); 

T बगैर किसी अड़चन है। मेरे कोड में, मैं

T AnotherMethod<T>() where T: class; 

प्रकार टी के एक तरीके के हस्ताक्षर के साथ एक अलग 3 पार्टी पुस्तकालय से एक विधि कॉल करने की जरूरत है, AnotherMethod के तर्क के लिए महत्वपूर्ण है। प्रतिबिंब का उपयोग किए बिना, मेरे कार्यान्वयन के भीतर AnotherMethod<T>() पर कॉल करने का कोई तरीका है? T एक मान प्रकार है तो मुझे स्पष्ट रूप से वैकल्पिक कार्रवाई करने की आवश्यकता है। क्या इस पर काम करने के लिए शायद ऑटोबॉक्स का कोई तरीका है?

Answer 1

मुझे नहीं लगता कि आप जो खोज रहे हैं वह प्रतिबिंब के बिना संभव है। सबसे अच्छा, आप बस AnotherMethod<object>() पर कॉल कर सकते हैं और परिणाम डाला जा सकता है। लेकिन यह वास्तव में सही काम करेगा अगर AnotherMethod के T आपके उद्देश्यों के लिए महत्वपूर्ण नहीं है।

Answer 2

मुझे यकीन नहीं है कि यह वही है जो आपको चाहिए, लेकिन यह आपको प्रतिबिंब का उपयोग किए बिना InterfaceMethod से AnotherMethod को कॉल करने की अनुमति देता है। यह अभी भी एक कनवर्ट का उपयोग करता है। चेंज टाइप हालांकि।

विचार क्लास जेनेरिक को एक बाधा (यहां टिन) के कार्यान्वयन के लिए करना है। फिर आप इंटरफ़ेस मोड के अनन्य प्रकार के टी को टिन में परिवर्तित करते हैं। अंत में आप बाध्य प्रकार के साथ एक और विधि को कॉल कर सकते हैं। निम्नलिखित तारों के साथ ठीक काम करता है।

public interface ITest 
{ 
    T InterfaceMethod<T> (T arg); 
} 

public interface ITest2 
{ 
    U AnotherMethod<U>(U arg) where U : class; 
} 

public class Test<Tin> : ITest, ITest2 where Tin : class 
{ 
    public T InterfaceMethod<T> (T arg) 
    { 
     Tin argU = arg as Tin; 
     if (argU != null) 
     { 
      Tin resultU = AnotherMethod(argU); 
      T resultT = (T)Convert.ChangeType(resultU,typeof(T)); 
      return resultT; 
     } 
     return default(T); 
    } 

    public U AnotherMethod<U> (U arg) where U : class { return arg; } 
} 

Answer 3

दूसरों को क्या कह रहे हैं कि आप इस तरह वस्तु के माध्यम से जा सकते हैं:

public interface ITest 
{ 
    T InterfaceMethod<T>(T arg); 
} 

public interface IAnotherTest 
{ 
    U AnotherMethod<U>(U arg) where U : class; 
} 

public class Test : ITest 
{ 
    private IAnotherTest _ianothertest; 

    public T InterfaceMethod<T>(T arg) 
    { 
     object argU = arg as object; 
     if (argU != null) 
     { 
      object resultU = _ianothertest.AnotherMethod(argU); 
      T resultT = (T)Convert.ChangeType(resultU, typeof(T)); 
      return resultT; 
     } 
     return default(T); 
    } 
}