So bestimmen Sie, ob ein Typ eine Schnittstelle mit C # -Reflexion implementiert

Hat Reflexion in C#Angebot eine Möglichkeit , wenn einige gegeben , um zu bestimmen System.TypeTyp Modelle einige Schnittstelle?

public interface IMyInterface {}

public class MyType : IMyInterface {}

// should yield 'true'
typeof(MyType)./* ????? */MODELS_INTERFACE(IMyInterface);

Sie haben einige Möglichkeiten:

1. typeof(IMyInterface).IsAssignableFrom(typeof(MyType))

2. typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface))

Bei einer generischen Schnittstelle ist das etwas anders.

typeof(MyType).GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMyInterface<>))

Verwendung Type.IsAssignableFrom:

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));

typeof(IMyInterface).IsAssignableFrom(someclass.GetType());

oder

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));

public static bool ImplementsInterface(this Type type, Type ifaceType) 
{
    Type[] intf = type.GetInterfaces();
    for(int i = 0; i < intf.Length; i++) 
    {
        if(intf[ i ] == ifaceType) 
        {
            return true;
        }
    }
    return false;
}

Ich denke, dies ist aus drei Gründen die richtige Version:

1. Es verwendet GetInterfaces und nicht IsAssignableFrom, es ist schneller, da IsAssignableFrom schließlich nach mehreren Überprüfungen GetInterfaces aufruft.
2. Es iteriert über das lokale Array, sodass keine Begrenzungsprüfungen durchgeführt werden.
3. Es verwendet den Operator ==, der für Type definiert ist, und ist daher wahrscheinlich sicherer als die Equals-Methode (die der Contains-Aufruf möglicherweise verwendet).

Ich habe gerade getan:

public static bool Implements<I>(this Type source) where I : class
{
  return typeof(I).IsAssignableFrom(source);
}

Ich wünschte, ich hätte sagen können where I : interface, ist aber interfacekeine generische Option für Parametereinschränkungen. classist so nah wie es nur geht.

Verwendungszweck:

if(MyType.Implements<IInitializable>())
  MyCollection.Initialize();

Ich habe nur gesagt, Implementsweil das intuitiver ist. Ich bekomme immer IsAssignableFromFlip-Flops.

Ändern von Jeffs Antwort für optimale Leistung (dank Leistungstest von Pierre Arnaud):

var type = typeof(MyType);
var implementsInterface = typeof(IMyInterface).IsAssignableFrom(type) && type.IsClass;

So finden Sie alle Typen, die eine Schnittstelle in einem bestimmten Bereich implementieren Assembly:

var implementations = typeof(TypeInTargetAssembly).Assembly.GetTypes()
                          .Where(t => typeof(IMyInterface).IsAssignableFrom(t) && t.IsClass);

Wie schon jemand anderes erwähnt: Benjamin 10. April 13 um 22:21 "

Es war sicher einfach, nicht darauf zu achten und die Argumente für IsAssignableFrom rückwärts zu bekommen. Ich werde jetzt mit GetInterfaces gehen: p -

Ein anderer Weg besteht darin, eine kurze Erweiterungsmethode zu erstellen, die zum Teil die "üblichste" Denkweise erfüllt (und sich einig ist, dass dies eine sehr kleine persönliche Entscheidung ist, um sie je nach den eigenen Vorlieben etwas "natürlicher" zu machen ):

public static class TypeExtensions
{
    public static bool IsAssignableTo(this Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }
}

Und warum nicht ein bisschen allgemeiner vorgehen (na ja, ich bin mir nicht sicher, ob es wirklich so interessant ist, ich nehme an, ich gebe nur eine weitere Prise 'Syntaxing'-Zucker):

public static class TypeExtensions
{
    public static bool IsAssignableTo(this Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }

    public static bool IsAssignableTo<TAssignable>(this Type type)
    {
        return IsAssignableTo(type, typeof(TAssignable));
    }
}

Ich denke, dass es auf diese Weise viel natürlicher sein könnte, aber noch einmal nur eine Frage sehr persönlicher Meinungen:

var isTrue = michelleType.IsAssignableTo<IMaBelle>();

Wenn Sie einen Typ oder eine Instanz haben, können Sie leicht überprüfen, ob diese eine bestimmte Schnittstelle unterstützen.

So testen Sie, ob ein Objekt eine bestimmte Schnittstelle implementiert:

if(myObject is IMyInterface) {
  // object myObject implements IMyInterface
}

So testen Sie, ob ein Typ eine bestimmte Schnittstelle implementiert:

if(typeof(IMyInterface).IsAssignableFrom(typeof(MyType))) {
  // type MyType implements IMyInterface
}

Wenn Sie ein generisches Objekt haben und eine Umwandlung sowie eine Überprüfung durchführen möchten, ob die Schnittstelle, in die Sie umgewandelt haben, implementiert ist, lautet der Code:

 var myCastedObject = myObject as IMyInterface;

    if(myCastedObject != null) {
      // object myObject implements IMyInterface
    }

IsAssignableFromwird jetzt verschoben nach TypeInfo:

typeof(ISMSRequest).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo());

Jeder, der danach sucht, könnte die folgende Erweiterungsmethode nützlich finden:

public static class TypeExtensions
{
    public static bool ImplementsInterface(this Type type, Type @interface)
    {
        if (type == null)
        {
            throw new ArgumentNullException(nameof(type));
        }

        if (@interface == null)
        {
            throw new ArgumentNullException(nameof(@interface));
        }

        var interfaces = type.GetInterfaces();
        if (@interface.IsGenericTypeDefinition)
        {
            foreach (var item in interfaces)
            {
                if (item.IsConstructedGenericType && item.GetGenericTypeDefinition() == @interface)
                {
                    return true;
                }
            }
        }
        else
        {
            foreach (var item in interfaces)
            {
                if (item == @interface)
                {
                    return true;
                }
            }
        }

        return false;
    }
}

Xunit-Tests:

public class TypeExtensionTests
{
    [Theory]
    [InlineData(typeof(string), typeof(IList<int>), false)]
    [InlineData(typeof(List<>), typeof(IList<int>), false)]
    [InlineData(typeof(List<>), typeof(IList<>), true)]
    [InlineData(typeof(List<int>), typeof(IList<>), true)]
    [InlineData(typeof(List<int>), typeof(IList<int>), true)]
    [InlineData(typeof(List<int>), typeof(IList<string>), false)]
    public void ValidateTypeImplementsInterface(Type type, Type @interface, bool expect)
    {
        var output = type.ImplementsInterface(@interface);
        Assert.Equal(expect, output);
    }
}

wie wäre es mit

if(MyType as IMyInterface != null)

?

Wie wäre es mit

typeof(IWhatever).GetTypeInfo().IsInterface

Eine richtige Antwort ist

typeof(MyType).GetInterface(nameof(IMyInterface)) != null;

Jedoch,

typeof(MyType).IsAssignableFrom(typeof(IMyInterface));

Möglicherweise wird ein falsches Ergebnis zurückgegeben, wie der folgende Code mit string und IConvertible zeigt:

    static void TestIConvertible()
    {
        string test = "test";
        Type stringType = typeof(string); // or test.GetType();

        bool isConvertibleDirect = test is IConvertible;
        bool isConvertibleTypeAssignable = stringType.IsAssignableFrom(typeof(IConvertible));
        bool isConvertibleHasInterface = stringType.GetInterface(nameof(IConvertible)) != null;

        Console.WriteLine($"isConvertibleDirect: {isConvertibleDirect}");
        Console.WriteLine($"isConvertibleTypeAssignable: {isConvertibleTypeAssignable}");
        Console.WriteLine($"isConvertibleHasInterface: {isConvertibleHasInterface}");
    }

Ergebnisse:

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True

Beachten Sie, dass bei einer generischen Schnittstelle IMyInterface<T>immer Folgendes zurückgegeben wird false:

  typeof(IMyInterface<>).IsAssignableFrom(typeof(MyType)) /* ALWAYS FALSE */

Das funktioniert auch nicht:

  typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface<>))  /* ALWAYS FALSE */

Wenn dies jedoch MyTypeimplementiert IMyInterface<MyType>wird, funktioniert dies und gibt Folgendes zurück true:

  typeof(IMyInterface<MyType>).IsAssignableFrom(typeof(MyType))

Wahrscheinlich kennen Sie den Typparameter Tzur Laufzeit jedoch nicht . Eine etwas hackige Lösung ist:

  typeof(MyType).GetInterfaces()
                .Any(x=>x.Name == typeof(IMyInterface<>).Name)

Jeffs Lösung ist etwas weniger hackig:

  typeof(MyType).GetInterfaces()
         .Any(i => i.IsGenericType 
             && i.GetGenericTypeDefinition() == typeof(IMyInterface<>));

Hier ist eine Erweiterungsmethode Type, die in jedem Fall funktioniert:

public static class TypeExtensions
{
    public static bool IsImplementing(this Type type, Type someInterface)
    {
        return type.GetInterfaces()
             .Any(i => i == someInterface 
                 || i.IsGenericType 
                    && i.GetGenericTypeDefinition() == someInterface);
    }
}

(Beachten Sie, dass oben linq verwendet wird, das wahrscheinlich langsamer als eine Schleife ist.)

Sie können dann tun:

   typeof(MyType).IsImplementing(IMyInterface<>)