कैसे निर्धारित करने के लिए एक प्रकार का एक विशिष्ट सामान्य इंटरफ़ेस प्रकार

Question

मान लें निम्न प्रकार परिभाषाओं को लागू करता है, तो:

public interface IFoo<T> : IBar<T> {} 
public class Foo<T> : IFoo<T> {} 

मैं कैसे बाहर प्रकार Foo सामान्य इंटरफ़ेस IBar<T> जब केवल घायल प्रकार उपलब्ध है लागू करता है कि क्या लगता है?

Answer 1

की तरह कुछ करने का उपयोग करके टीसीके से जवाब यह निम्नलिखित LINQ क्वेरी के साथ भी किया जा सकता है:

bool isBar = foo.GetType().GetInterfaces().Any(x => 
    x.IsGenericType && 
    x.GetGenericTypeDefinition() == typeof(IBar<>)); 

Answer 2

आपको जेनेरिक इंटरफेस के एक निर्मित प्रकार के खिलाफ जांच करनी है।

आप कुछ इस तरह करना होगा:

foo is IBar<String> 

क्योंकि IBar<String> प्रतिनिधित्व करता है कि निर्माण किया प्रकार। आपको ऐसा करने का कारण यह है कि यदि T आपकी जांच में अपरिभाषित है, तो संकलक यह नहीं जानता कि आपका मतलब IBar<Int32> या IBar<SomethingElse> है।

Answer 3

आप विरासत पेड़ के माध्यम से बढ़ जाती हैं और पेड़ में प्रत्येक वर्ग के लिए सभी इंटरफ़ेस मिल जाए, और Type.GetGenericTypeDefinitionअगर इंटरफ़ेस सामान्य है बुला के नतीजे से typeof(IBar<>) तुलना करने के लिए किया है। यह निश्चित रूप से थोड़ा दर्दनाक है।

अधिक जानकारी और कोड के लिए this answer और these ones देखें।

Answer 4

public interface IFoo<T> : IBar<T> {} 
public class Foo : IFoo<Foo> {} 

var implementedInterfaces = typeof(Foo).GetInterfaces(); 
foreach(var interfaceType in implementedInterfaces) { 
    if (false == interfaceType.IsGeneric) { continue; } 
    var genericType = interfaceType.GetGenericTypeDefinition(); 
    if (genericType == typeof(IFoo<>)) { 
     // do something ! 
     break; 
    } 
} 

Answer 5

सभी public class Foo : IFoo<T> {} सबसे पहले क्योंकि आप टी के बजाय एक वर्ग निर्दिष्ट करने की आवश्यकता संकलन नहीं है, लेकिन यह सोचते हैं आप public class Foo : IFoo<SomeClass> {}

तो अगर आप ऐसा करेंगे

Foo f = new Foo(); 
IBar<SomeClass> b = f as IBar<SomeClass>; 

if(b != null) //derives from IBar<> 
    Blabla(); 

Answer 6

एक सहायक विधि विस्तार के रूप में

public static bool Implements<I>(this Type type, I @interface) where I : class 
{ 
    if(((@interface as Type)==null) || !(@interface as Type).IsInterface) 
     throw new ArgumentException("Only interfaces can be 'implemented'."); 

    return (@interface as Type).IsAssignableFrom(type); 
} 

उदाहरण उपयोग:

var testObject = new Dictionary<int, object>(); 
result = testObject.GetType().Implements(typeof(IDictionary<int, object>)); // true! 

Answer 7

मैं @GenericProgrammers विस्तार विधि का एक थोड़ा सरल संस्करण का उपयोग कर रहा:

public static bool Implements<TInterface>(this Type type) where TInterface : class { 
    var interfaceType = typeof(TInterface); 

    if (!interfaceType.IsInterface) 
     throw new InvalidOperationException("Only interfaces can be implemented."); 

    return (interfaceType.IsAssignableFrom(type)); 
} 

उपयोग:

if (!featureType.Implements<IFeature>()) 
     throw new InvalidCastException(); 

Answer 8

अतिरिक्त क्रेडिट के लिए आप AmbiguousMatchException पकड़ सकते थे यदि आप किसी विशिष्ट अपने Ibar क्वेरी के साथ सामान्य प्रकार पैरामीटर देना चाहते थे: 210 वहाँ कुछ भी गलत निम्नलिखित नहीं होना चाहिए।

Answer 9

पूरी तरह से प्रकार प्रणाली से निपटने के लिए, मैं आप प्रत्यावर्तन को संभालने के लिए, उदाहरण के लिए की जरूरत है IList<T>: ICollection<T>: IEnumerable<T>, जिसके बिना आप नहीं जानते कि IList<int> अंत में IEnumerable<> लागू करता है।

/// <summary>Determines whether a type, like IList&lt;int&gt;, implements an open generic interface, like 
    /// IEnumerable&lt;&gt;. Note that this only checks against *interfaces*.</summary> 
    /// <param name="candidateType">The type to check.</param> 
    /// <param name="openGenericInterfaceType">The open generic type which it may impelement</param> 
    /// <returns>Whether the candidate type implements the open interface.</returns> 
    public static bool ImplementsOpenGenericInterface(this Type candidateType, Type openGenericInterfaceType) 
    { 
     Contract.Requires(candidateType != null); 
     Contract.Requires(openGenericInterfaceType != null); 

     return 
      candidateType.Equals(openGenericInterfaceType) || 
      (candidateType.IsGenericType && candidateType.GetGenericTypeDefinition().Equals(openGenericInterfaceType)) || 
      candidateType.GetInterfaces().Any(i => i.IsGenericType && i.ImplementsOpenGenericInterface(openGenericInterfaceType)); 

    } 

Answer 10

मामले आप एक विस्तार विधि है कि जेनेरिक आधार प्रकार के साथ-साथ इंटरफेस का समर्थन चाहते थे में, मैं विस्तार किया है sduplooy का जवाब: प्रकार इनहेरिट या एक सामान्य लागू करता है, तो

public static bool InheritsFrom(this Type t1, Type t2) 
    { 
     if (null == t1 || null == t2) 
      return false; 

     if (null != t1.BaseType && 
      t1.BaseType.IsGenericType && 
      t1.BaseType.GetGenericTypeDefinition() == t2) 
     { 
      return true; 
     } 

     if (InheritsFrom(t1.BaseType, t2)) 
      return true; 

     return 
      (t2.IsAssignableFrom(t1) && t1 != t2) 
      || 
      t1.GetInterfaces().Any(x => 
       x.IsGenericType && 
       x.GetGenericTypeDefinition() == t2); 
    } 

Answer 11

विधि की जाँच करने के टाइप करें:

public static bool IsTheGenericType(this Type candidateType, Type genericType) 
    { 
     return 
      candidateType != null && genericType != null && 
      (candidateType.IsGenericType && candidateType.GetGenericTypeDefinition() == genericType || 
      candidateType.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == genericType) || 
      candidateType.BaseType != null && candidateType.BaseType.IsTheGenericType(genericType)); 
    }