निर्धारित करें कि कोई वर्ग एक बहुत ही विशिष्ट इंटरफ़ेस लागू करता है

Question

इस विषय के बारे में बहुत सारे प्रश्न हैं, लेकिन मेरे पास इसका थोड़ा सा संस्करण है।

interface IFoo { } 
interface IBar : IFoo { } 
class Foo : IFoo { } 
class Bar : IBar { } 

bool Implements_IFoo(Type type) { /* ??? */ } 

अब, कहानी का मोड़: विधि Implements_IFoo ही सच्चा लौट जाना चाहिए जब प्रकार IFoo केवल और नहीं लागू करता है इंटरफेस IFoo से व्युत्पन्न के किसी भी

हम निम्नलिखित कोड है।

Implements_IFoo(typeof(Foo)); // Should return true 

Implements_IFoo(typeof(Bar)); // Should return false as Bar type 
           // implements an interface derived from IFoo 

ध्यान दें कि वहाँ IFoo से प्राप्त कई इंटरफेस हो सकता है और आप जरूरी अपने अस्तित्व के बारे में पता नहीं है: यहाँ इसे समझने के लिए इस विधि के कुछ उदाहरण हैं।

स्पष्ट विधि है IFoo से प्रतिबिंबित सभी इंटरफ़ेस को प्रतिबिंब के माध्यम से प्राप्त करना और फिर टाइपफ़ोफ़ (बार) की जांच करें। गेटइंटरफेस() उनमें से कोई भी मौजूद है। लेकिन मैं सोच रहा था कि कोई और अधिक सुरुचिपूर्ण समाधान के साथ आ सकता है।

पीएस प्रश्न कुछ कोड से निकला है जो मैंने पाया है कि कक्षाओं पर इस चेक का उपयोग करता है (if(obj.GetType() == typeof(BaseClass)) { ... })। हम अब विशेष कोड के साथ कक्षाओं को इंटरफेस के साथ बदल रहे हैं। इसके अलावा, बस मामले में - मैं इस चेक को बुलियन ध्वज के रूप में कार्यान्वित कर रहा हूं, इसलिए यह प्रश्न पूरी तरह से काल्पनिक है।

Answer 1

मैं क्योंकि यह मज़ा की तरह लग रहा एक कोशिश थी, और यह आपके उदाहरण के लिए काम करता है:

bool ImplementsIFooDirectly(Type t) { 
    if (t.BaseType != null && ImplementsIFooDirectly(t.BaseType)) { 
     return false; 
    } 
    foreach (var intf in t.GetInterfaces()) { 
     if (ImplementsIFooDirectly(intf)) { 
      return false; 
     } 
    } 
    return t.GetInterfaces().Any(i => i == typeof(IFoo)); 
} 

परिणाम:

ImplementsIFooDirectly(typeof(IFoo)); // false 
ImplementsIFooDirectly(typeof(Bar)); // false 
ImplementsIFooDirectly(typeof(Foo)); // true 
ImplementsIFooDirectly(typeof(IBar)); // true 

यह से ली गई सभी इंटरफेस के लिए नहीं लगती है IFoo, यह सिर्फ विरासत/इंटरफेस कार्यान्वयन श्रृंखला की यात्रा करता है और देखता है कि IFoo इस प्रकार के सटीक स्तर के अलावा किसी भी स्तर पर मौजूद है या नहीं।

यह भी पता लगाता है कि इंटरफ़ेस को बेस प्रकार के माध्यम से विरासत में मिला है या नहीं। सुनिश्चित नहीं है कि आप यही चाहते हैं।

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

Answer 2

क्या आपने कीवर्ड is का उपयोग करने का प्रयास किया था?

सामान्य रूप से बीटीडब्ल्यू, यदि आपके पास एक तार्किक मामला है जहां कुछ वर्ग को कुछ बेस क्लास के प्रकार की आवश्यकता होती है लेकिन विरासत में से कोई भी नहीं है, तो शायद यह गलत ओओ डिज़ाइन है, जो Liskov substitution principle का उल्लंघन कर सकता है।

Answer 3

उदाहरण के लिए निम्नलिखित साइट देखें कि इसे कैसे कार्यान्वित किया जा सकता है;

C# is keyword usage

अनिवार्य रूप से आप यह निर्धारित करने वस्तु यह वर्ग विरासत ढेर के हिस्से के रूप में एक वर्ग के प्रकार रहता है कि क्या 'है' कीवर्ड का उपयोग कर सकते हैं।

class Director : Owner { } 
class Developer : Employee { } 
.. 
var dave = new Developer(); 
var steve = new Director(); 
var isEmployee = dave is Employee; // true 
var isAlsoEmploye = steve is Employee; // false 

अपने उदाहरण समारोह के साथ

लाइन में:

bool Implements_Type(object instance, Type type) { 
return instance is type; 
} 

Answer 4

प्रकार वर्ग एक विधि GetInterface कहा जाता है का उपयोग कर सकते है।

bool Implements_IFoo(Type t) 
    { 
     return t.GetInterface(typeof(IFoo).Name) != null; 
    } 

Answer 5

static bool Implements_IFoo(Type type) 
{ 
    if (typeof(IFoo).IsAssignableFrom(type.BaseType)) 
    return false; 

    var barInterfaces = type.GetInterfaces() 
    .Where(iface => typeof(IFoo).IsAssignableFrom(iface)) 
    .ToArray(); 

    return barInterfaces.Length > 0 
    && barInterfaces.Length == barInterfaces.Count(iface => iface == typeof(IFoo)); 
} 
static bool Implements_IFoo_Optimized(Type type) 
{ 
    if (typeof(IFoo).IsAssignableFrom(type.BaseType)) 
    return false; 

    return type.GetInterfaces() 
    .Where(iface => typeof(IFoo).IsAssignableFrom(iface)) 
    .Count() == 1; 
} 

Answer 6

इस चाल करना चाहिए:

public bool ImplementsIFooOnly(Type type) 
{ 
    return !type.GetInterfaces().Any(t => 
       { 
        return t is IFoo && !t.Equals(typeof(IFoo)); 
       }); 
} 

शायद और अधिक कुशल तरीके से कर रहे हैं।