सी # गुमनाम रूप से कार्यान्वित इंटरफेस (या अमूर्त वर्ग)

Question

जावा में एक अज्ञात वर्ग के साथ एक इंटरफ़ेस का विस्तार करना संभव है जिसे आप फ्लाई पर कार्यान्वित कर सकते हैं। उदाहरण:

Runnable myRunnable = new Runnable() 
{ 
    @Override 
    public void run() { /**/ } 
} 

(पर अधिक: http://www.techartifact.com/blogs/2009/08/anonymous-classes-in-java.html#ixzz1k07mVIeO)

सी # में यह संभव है? यदि नहीं, तो सबक्लास के बड़े पैमाने पर लागू होने पर भरोसा करने के बिना व्यावहारिक विकल्प क्या हैं?

Answer 1

नहीं, आप इसे सी # में नहीं कर सकते हैं - लेकिन आमतौर पर वैकल्पिक डिजाइन दृष्टिकोण इसके बजाय प्रतिनिधि का उपयोग करना है। उदाहरण में आप, दे दिया है Runnable आमतौर पर ThreadStart का उपयोग कर प्रस्तुत किया जाता है, और आप एक गुमनाम विधि या लैम्ब्डा अभिव्यक्ति का उपयोग कर सकते हैं: सही हस्ताक्षर के साथ

ThreadStart start =() => 
{ 
    // Do stuff here 
}; 

या यदि आपने अभी चलाने के लिए एक विधि है, आप कर सकते हैं

ThreadStart start = MethodToRunInThread; 

या Thread निर्माता कॉल में: एक विधि समूह रूपांतरण का उपयोग

Thread t = new Thread(MethodToRunInThread); 
t.Start(); 

आप तो वास्तव में को एक इंटरफ़ेस को लागू करने की आवश्यकता है, आपको इसे वास्तव में कार्यान्वित करना होगा (संभवतः एक निजी नेस्टेड क्लास में)। हालांकि, यह मेरे अनुभव में अक्सर सी # में नहीं आता है - आम तौर पर सी # इंटरफेस ऐसे प्रकार होते हैं जो प्राकृतिक रूप से जावा में भी "वास्तविक" कार्यान्वयन की मांग करेंगे।

Answer 2

जैसा कि जॉन ने बताया कि सी # में यह संभव नहीं है।

सी # में एक वैकल्पिक पैटर्न एक कारखाने के संयोजन का उपयोग करना है और एक इंटरफेस के फ्लाई कार्यान्वयन की अनुमति देने के लिए एक प्रतिनिधि है। अनिवार्य रूप से फैक्ट्री इंटरफ़ेस की प्रत्येक विधि के लिए एक प्रतिनिधि में ले जाती है और उन्हें बैकिंग कार्यान्वयन के रूप में उपयोग करती है। उदाहरण के लिए, यहां IComparable<T> के लिए एक संस्करण है।

public static class ComparableFactory { 
    private sealed ComparableImpl<T> : IComparable<T> { 
    internal Func<T, T, int> _compareFunc; 
    public int Compare(T left, T right) { 
     return _compareFunc(left, right); 
    } 
    } 
    public IComparable<T> Create<T>(Func<T, T, int> compareFunc) { 
    return new ComparableImpl<T>() { _compareFunc = compareFunc }; 
    } 
} 

... 

IComparable<Person> impl = CompareableFactory.Create<Person>(
    (left, right) => left.Age.CompareTo(right.Age));