Collection<T> वर्ग से ICollection<T>.IsReadOnly संपत्ति का स्पष्ट इंटरफेस कार्यान्वयन ओवरराइड करने के लिए प्रयास करते समय, मैं कुछ दस्तावेज़ों में कहा है कि स्पष्ट इंटरफेस सदस्य कार्यान्वयन क्योंकि वे इस तरह के रूप संशोधक नहीं हो सकता ओवरराइड नहीं किया जा सकता है के लिए आया था virtual या abstract। MSDN पर वे स्पष्ट इंटरफ़ेस सदस्य कार्यान्वयन द्वारा बुलाए जाने वाले एक अन्य सार या वर्चुअल सदस्य को बनाकर विरासत के लिए एक स्पष्ट इंटरफ़ेस सदस्य कार्यान्वयन को कैसे उपलब्ध कराते हैं, यह निर्दिष्ट करते हैं। अभी तक कोई समस्या नहीं है।सी #: इंटरफ़ेस निर्दिष्ट द्वारा संपत्ति अधिभावी स्पष्ट
लेकिन तब मुझे आश्चर्य है: ऐसा क्यों है किसी भी स्पष्ट रूप से कार्यान्वित इंटरफ़ेस सदस्य ओवरराइड करने के लिए बस इंटरफ़ेस स्पष्ट निर्दिष्ट द्वारा सी # में संभव है?
उदाहरण के लिए, मैं एक संपत्ति और विधि के साथ इस तरह एक सरल अंतरफलक है, मान लीजिए:
public interface IMyInterface
{
bool AlwaysFalse { get; }
bool IsTrue(bool value);
}
और एक वर्ग A जो इंटरफ़ेस स्पष्ट रूप से लागू करता है, और एक विधि Test() जो अपनी ही इंटरफ़ेस कॉल है सदस्य कार्यान्वयन।
public class A : IMyInterface
{
bool IMyInterface.AlwaysFalse
{ get { return false; } }
bool IMyInterface.IsTrue(bool value)
{ return value; }
public bool Test()
{ return ((IMyInterface)this).AlwaysFalse; }
}
आप देख सकते हैं, चार सदस्यों में से कोई भी आभासी या सार है, इसलिए जब मैं इस तरह एक वर्ग B को परिभाषित:
public class B : A
{
public bool AlwaysFalse
{ get { return true; } }
public bool IsTrue(bool value)
{ return !value; }
}
तो फिर तुम करने के लिए B कलाकारों का एक उदाहरण उम्मीद थी AA की तरह व्यवहार करने के लिए। और यह करता है:
A a = new A();
Console.WriteLine(((IMyInterface)a).AlwaysFalse); // False
Console.WriteLine(((IMyInterface)a).IsTrue(false)); // False
Console.WriteLine(a.Test()); // False
A b = new B();
Console.WriteLine(((IMyInterface)b).AlwaysFalse); // False
Console.WriteLine(((IMyInterface)b).IsTrue(false)); // False
Console.WriteLine(b.Test()); // False
अब पकड़ आता है। एक वर्ग C जो वर्ग घोषणा में एक बात को छोड़कर B का एक सटीक प्रतिलिपि है बनाएँ:
public class C : A, IMyInterface
{ /* ... same as B ... */ }
अब C का एक उदाहरण है, जब A लिए डाली, A की तरह व्यवहार नहीं करता है लेकिन जैसे C:
A c = new C();
Console.WriteLine(((IMyInterface)c).AlwaysFalse); // True
Console.WriteLine(((IMyInterface)c).IsTrue(false)); // True
Console.WriteLine(c.Test()); // True
यहां तक कि Test() विधि अब C में ओवरराइड विधि को कॉल करती है! ऐसा क्यों है?
बहुत ही दिलचस्प सवाल! –