So ermitteln Sie, ob ein Typ einen bestimmten generischen Schnittstellentyp implementiert

Übernehmen die folgenden type-Definitionen:

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

Wie finde ich heraus, ob der Typ Foo implementiert die generische Schnittstelle IBar<T> wenn nur die entstellten Typ verfügbar ist?

InformationsquelleAutor der Frage sduplooy | 2009-02-02

  1. 319

    Mithilfe die Antwort von TcKs es kann auch gemacht werden mit die folgende LINQ-Abfrage:

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

    InformationsquelleAutor der Antwort sduplooy

  2. 32

    Müssen Sie gehen bis über die Vererbung von Struktur und finden Sie alle Schnittstellen, die für jede Klasse in den Baum, und vergleichen typeof(IBar<>) mit dem Ergebnis des Aufrufs Type.GetGenericTypeDefinition wenn die Schnittstelle ist generisch. Es ist alles ein bisschen schmerzhaft, sicherlich.

    Sehen diese Antwort und diese für mehr info und den code.

    InformationsquelleAutor der Antwort Jon Skeet

  3. 19
    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;
    }
}

    InformationsquelleAutor der Antwort TcKs

  4. 9

    Als Hilfsmethode Erweiterung

    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);
}

    Beispiel:

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

    InformationsquelleAutor der Antwort GenericProgrammer

  5. 4

    Sie haben zu prüfen, gegen einen konstruierten Typ der generischen Schnittstelle.

    Haben Sie etwas wie das hier tun:

    foo is IBar<String>

    weil IBar<String> darstellt, konstruierten Typ. Der Grund Sie haben, dies zu tun ist, weil, wenn T ist undefiniert, in den check, den der compiler nicht weiß, ob Sie meine IBar<Int32> oder IBar<SomethingElse>.

    InformationsquelleAutor der Antwort Andrew Hare

  6. 4

    Bin ich mit einer etwas einfacheren version von @GenericProgrammers extension Methode:

    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));
}

    Verwendung:

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

    InformationsquelleAutor der Antwort Ben Foster

  7. 3

    Zunächst public class Foo : IFoo<T> {} nicht kompilieren, da müssen Sie eine Klasse anstelle von T, aber nur dann, wenn Sie etwas tun, wie public class Foo : IFoo<SomeClass> {}

    dann, wenn Sie

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

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

    InformationsquelleAutor der Antwort Pablo Retyk

  8. 3

    Zur Bewältigung der Typ system komplett, ich denke, Sie müssen zu behandeln, Rekursion, z.B. IList<T> : ICollection<T> : IEnumerable<T>ohne die Sie nicht wüssten, dass IList<int> letztlich implementiert 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));

    }

    InformationsquelleAutor der Antwort Sebastian Good

  9. 1

    In den Fall, Sie wollten eine Erweiterung Methode, das generische Basistypen sowie Schnittstellen habe ich ausgebaut sduplooy Antwort:

        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);
    }

    InformationsquelleAutor der Antwort Philip Pittle

  10. 1

    Methode zu überprüfen, ob der Typ erbt oder implementiert einen generischen Typ: 

       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));
    }

    InformationsquelleAutor der Antwort Derek Greer

  11. 0

    Sollte eigentlich nichts schief die folgenden:

    bool implementsGeneric = (anObject.Implements("IBar`1") != null);

    Für zusätzliche Kredit, den Sie fangen konnten AmbiguousMatchException, wenn Sie wollten, um einen spezifischen generischen Typ-parameter mit Ihren IBar-Abfrage.

    InformationsquelleAutor der Antwort mindlace

Schreibe einen Kommentar