Wie man bestimmt, ob ein Typ eine Schnittstelle mit C#-Reflexion implementiert

Question

Bietet Reflexion in C# eine Möglichkeit festzustellen, ob ein bestimmter System.Type ein bestimmtes Interface modelliert?

public interface IMyInterface {}

public class MyType : IMyInterface {}

// sollte 'true' ergeben
typeof(MyType)./* ????? */MODELS_INTERFACE(IMyInterface);

Answer 1

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

Answer 2

IsAssignableFrom wurde nun zu TypeInfo verschoben:

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

Answer 3

Eine korrekte Antwort ist

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

Jedoch könnte

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

eine falsche Antwort liefern, wie der folgende Code zeigt mit string und IConvertible:

    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

Answer 4

Was ist mit

if(MyType as IMyInterface != null)

?

Answer 5

Was ist mit

typeof(IWhatever).GetTypeInfo().IsInterface