Wie erkennen, ob Typ Ein weiterer Allgemein Typ

Question

Beispiel ist:

public static void DoSomething<K,V>(IDictionary<K,V> items) { 
    items.Keys.Each(key => { 
     if (items[key] **is IEnumerable<?>**) { /* do something */ } 
     else { /* do something else */ } 
} 

Kann dies ohne Reflexion zu tun? Wie sage ich IEnumerable in C#? Soll ich IEnumerable verwenden, da IEnumerable <> IEnumerable implementiert?

Answer 1

The previously accepted answer ist schön, aber es ist falsch. Zum Glück ist der Fehler ein kleiner. Die Überprüfung auf IEnumerable ist nicht genug, wenn Sie wirklich über die generische Version der Schnittstelle informiert werden möchten; Es gibt viele Klassen, die nur die nicht generische Schnittstelle implementieren. Ich werde die Antwort in einer Minute geben. Zunächst aber möchte ich darauf hinweisen, dass die akzeptierte Antwort zu kompliziert ist, da der folgende Code das gleiche unter den gegebenen Umständen erreichen würde:

if (items[key] is IEnumerable) 

Dies gilt noch mehr, weil sie separat für jedes Element funktioniert (und nicht auf ihre gemeinsame Unterklasse, V).

Jetzt für die richtige Lösung. Dies ist ein wenig komplizierter, weil wir den generischen Typ IEnumerable`1 nehmen (das heißt, der Typ IEnumerable<> mit einem Typ-Parameter) und injizieren das Recht allgemeine Argument:

static bool IsGenericEnumerable(Type t) { 
    var genArgs = t.GetGenericArguments(); 
    if (genArgs.Length == 1 && 
      typeof(IEnumerable<>).MakeGenericType(genArgs).IsAssignableFrom(t)) 
     return true; 
    else 
     return t.BaseType != null && IsGenericEnumerable(t.BaseType); 
} 

Sie die Richtigkeit dieser Code testen können leicht :

var xs = new List<string>(); 
var ys = new System.Collections.ArrayList(); 
Console.WriteLine(IsGenericEnumerable(xs.GetType())); 
Console.WriteLine(IsGenericEnumerable(ys.GetType())); 

ergibt:

True 
False 

übermäßig besorgt über die Tatsache werden Sie nicht, dass diese Reflexion verwendet. Es ist zwar wahr, dass dies einen Laufzeit-Overhead hinzufügt, aber auch die Verwendung des Operators is.

Natürlich ist der obige Code furchtbar eingeschränkt und könnte in eine allgemein anwendbare Methode, IsAssignableToGenericType erweitert werden. Die folgende Implementierung ist etwas falsch und ich lasse es hier nur für historische Zwecke. Nicht verwenden.Stattdessen James has provided an excellent, correct implementation in his answer.

public static bool IsAssignableToGenericType(Type givenType, Type genericType) { 
    var interfaceTypes = givenType.GetInterfaces(); 

    foreach (var it in interfaceTypes) 
     if (it.IsGenericType) 
      if (it.GetGenericTypeDefinition() == genericType) return true; 

    Type baseType = givenType.BaseType; 
    if (baseType == null) return false; 

    return baseType.IsGenericType && 
     baseType.GetGenericTypeDefinition() == genericType || 
     IsAssignableToGenericType(baseType, genericType); 
} 

Es schlägt fehl, wenn die genericType die gleiche wie givenType ist; Aus dem gleichen Grund, versagt es für Nullable Types, das heißt

IsAssignableToGenericType(typeof(List<int>), typeof(List<>)) == false 
IsAssignableToGenericType(typeof(int?), typeof(Nullable<>)) == false 

ich eine gist with a comprehensive suite of test cases erstellt haben.

Answer 2

if (typeof(IEnumerable).IsAssignableFrom(typeof(V))) { 

Answer 3

Ich bin mir nicht sicher, ich verstehe, was Sie hier meinen. Möchten Sie wissen, ob das Objekt von generischen Typ ist oder möchten Sie testen, ob es sich um einen spezifischen generischen Typ handelt? Oder willst du nur wissen, ob es aufzählbar ist?

Ich glaube nicht, dass der erste möglich ist. Der zweite ist definitiv möglich, behandle ihn wie jeden anderen Typ. Testen Sie es als drittes gegen IEnumerable, wie Sie es vorgeschlagen haben.

Außerdem können Sie den 'is'-Operator für Typen nicht verwenden.

// Not allowed 
if (string is Object) 
    Foo(); 
// You have to use 
if (typeof(object).IsAssignableFrom(typeof(string)) 
    Foo(); 

Weitere Details finden Sie unter this question about types. Vielleicht hilft es dir.

Answer 4

Sie wollen die Type.IsInstanceOfType Methode zu überprüfen,

Answer 5

ich Überlastung verwenden würde:

public static void DoSomething<K,V>(IDictionary<K,V> items) 
    where V : IEnumerable 
{ 
    items.Keys.Each(key => { /* do something */ }); 
} 

public static void DoSomething<K,V>(IDictionary<K,V> items) 
{ 
    items.Keys.Each(key => { /* do something else */ }); 
} 

Answer 6

Ein Wort der Warnung über generische Typen und mit IsAssignableFrom() ...

Angenommen, Sie haben die folgenden:

public class MyListBase<T> : IEnumerable<T> where T : ItemBase 
{ 
} 

public class MyItem : ItemBase 
{ 
} 

public class MyDerivedList : MyListBase<MyItem> 
{ 
} 

auf der Basis Listentyp oder auf der abgeleiteten Listentyp aufrufen IsAssignableFrom wird return false, aber eindeutig MyDerivedList erbt MyListBase<T>. (Eine kurze Notiz für Jeff, Generika absolut muss in einem Codeblock oder Tilden gewickelt werden, um die <T> zu bekommen, sonst ist es weggelassen. Ist das beabsichtigt?) Das Problem rührt von der Tatsache, dass MyListBase<MyItem> als ein ganz anderer Typ behandelt wird MyListBase<T>. Der folgende Artikel könnte das ein wenig besser erklären. Statt http://mikehadlow.blogspot.com/2006/08/reflecting-generics.html

, versuchen Sie die folgende rekursive Funktion:

public static bool IsDerivedFromGenericType(Type givenType, Type genericType) 
    { 
     Type baseType = givenType.BaseType; 
     if (baseType == null) return false; 
     if (baseType.IsGenericType) 
     { 
      if (baseType.GetGenericTypeDefinition() == genericType) return true; 
     } 
     return IsDerivedFromGenericType(baseType, genericType); 
    } 

/EDIT: Konrads neuen Beitrag, der auch die allgemeine Rekursion berücksichtigt als Schnittstellen genau das Richtige ist. Sehr gute Arbeit. :)

/EDIT2: Wenn eine Überprüfung vorgenommen wird, ob genericType eine Schnittstelle ist, könnten Leistungsvorteile realisiert werden. Die Prüfung kann eine sein, wenn Block um den aktuellen Interface-Code, aber wenn Sie sich mit der .NET 3.5, ein Freund von mir bietet folgendes interessieren:

public static bool IsAssignableToGenericType(Type givenType, Type genericType) 
    { 
     var interfaces = givenType.GetInterfaces().Where(it => it.IsGenericType).Select(it => it.GetGenericTypeDefinition()); 
     var foundInterface = interfaces.FirstOrDefault(it => it == genericType); 
     if (foundInterface != null) return true; 

     Type baseType = givenType.BaseType; 
     if (baseType == null) return false; 

     return baseType.IsGenericType ? 
      baseType.GetGenericTypeDefinition() == genericType : 
      IsAssignableToGenericType(baseType, genericType); 
    } 

Answer 7

ich eine solche Situation zu denken verwendet auflösbar sein kann in ähnlicher Weise wie @Thomas Danecker der solution, aber das Hinzufügen eines weiteren Template-Argument:

public static void DoSomething<K, V, U>(IDictionary<K,V> items) 
    where V : IEnumerable<U> { /* do something */ } 
public static void DoSomething<K, V>(IDictionary<K,V> items) 
          { /* do something else */ } 

aber ich merkte jetzt, dass es Arbeit does't, wenn ich die Template-Argumente des ersten Verfahrens explizit angeben. Dies ist eindeutig nicht für jeden Artikel im Wörterbuch angepasst, aber es kann eine Art Lösung des armen Mannes sein.

Ich wäre sehr dankbar, wenn jemand etwas falsches darauf hinweisen könnte, dass ich hier getan hätte.

Answer 8

Vielen Dank für diesen Beitrag. Ich wollte eine Version von Konrad Rudolphs Lösung anbieten, die für mich besser funktioniert hat. Ich hatte kleinere Probleme mit dieser Version, vor allem bei der Prüfung, ob ein Typ ein Nullable-Wertetyp:

public static bool IsAssignableToGenericType(Type givenType, Type genericType) 
{ 
    var interfaceTypes = givenType.GetInterfaces(); 

    foreach (var it in interfaceTypes) 
    { 
     if (it.IsGenericType && it.GetGenericTypeDefinition() == genericType) 
      return true; 
    } 

    if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType) 
     return true; 

    Type baseType = givenType.BaseType; 
    if (baseType == null) return false; 

    return IsAssignableToGenericType(baseType, genericType); 
} 

Answer 9

Danke für die tolle Info. Aus Gründen der Benutzerfreundlichkeit habe ich dies in eine Erweiterungsmethode umgewandelt und auf eine einzige Anweisung reduziert.

sometype:

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

Jetzt kann es leicht mit aufgerufen werden.IsAssignableToGenericType (typeof (MyGenericType <>))