如何使用 C# 反射确定类型是否实现接口

Question

C# 中的反射是否提供了一种方法来确定某些给定的 System.Type 类型是否模型了某个接口？

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

Answer 1

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

我认为这是正确的版本，原因有三个：

1. 它使用 GetInterfaces 而不是 IsAssignableFrom，它更快，因为
   IsAssignableFrom 经过多次检查后最终确实调用
   获取接口。
2. 它迭代本地数组，所以会有
   没有边界检查。
3. 它使用 == 运算符，该运算符定义为
   类型，因此可能比 Equals 方法更安全（即 Contains
   调用，最终会使用）。

Answer 2

如果您有类型或实例，您可以轻松检查它们是否支持特定接口。

测试对象是否实现某个接口：

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

测试类型是否实现某个接口：

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

如果您有一个泛型对象并且想要进行强制转换并检查您强制转换到的接口是否已实现，则代码为：

 var myCastedObject = myObject as IMyInterface;

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

Answer 3

我刚刚做了：

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

我希望我可以说where I：interface，但是interface不是通用参数约束选项。 class 是最接近的。

用法：

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

我只是说Implements，因为这样更直观。我总是会遇到 IsAssignableFrom 翻转的情况。

Answer 4

正如其他人已经提到的：
本杰明 2013 年 4 月 10 日 22:21"

很容易不注意并得到论据
IsAssignableFrom 向后。我现在将使用 GetInterfaces :p –

好吧，另一种方法是创建一个简短的扩展方法，在某种程度上实现“最常用”的思维方式（并同意这是一个非常小的个人选择，使其成为可能）根据个人喜好稍微“更自然”）：

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

为什么不更通用一点（好吧不确定它是否真的那么有趣，我想我只是再传递一点“语法”糖）：

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

我认为它这样可能会更自然，但这又只是个人意见的问题：

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

Answer 5

修改 Jeff 的答案以获得最佳性能（感谢 Pierre Arnaud 的性能测试）：

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

要查找在给定 Assembly 中实现接口的所有类型：

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

Answer 6

请注意，如果您有一个通用接口 IMyInterface 那么这将始终返回 false：

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

这也不起作用：

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

但是，如果MyType 实现了 IMyInterface 这有效并返回 true：

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

但是，您可能在运行时将不知道类型参数T。一个有点老套的解决方案是：

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

杰夫的解决方案不那么老套：

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

这里有一个适用于任何情况的 Type 扩展方法：

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

（请注意上面使用了 linq，它可能比循环慢。）

然后你可以这样做：

   typeof(MyType).IsImplementing(IMyInterface<>)

Answer 7

搜索此内容的任何人可能会发现以下扩展方法很有用：

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 测试：

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

Answer 8

IsAssignableFrom 现在移至 TypeInfo：

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

Answer 9

正确的答案是

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

但是，

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

可能会返回错误的结果，如以下代码所示，使用字符串和 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}");
    }

结果：

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True

Answer 10

怎么样

if(MyType as IMyInterface != null)

？

Answer 11

怎么样

typeof(IWhatever).GetTypeInfo().IsInterface

Answer 12

如果你不需要使用反射并且你有一个对象，你可以使用这个：

if(myObject is IMyInterface )
{
 // it's implementing IMyInterface
}

Answer 13

您有几种选择：

1. typeof(IMyInterface).IsAssignableFrom(typeof(MyType)) 或（从 .NET 5 开始）等效的逆，typeof(MyType).IsAssignableTo(typeof(IMyInterface) ))
2. typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface))
3. 在 C# 6+ 中，您可以使用 nameof 运算符 typeof(MyType).GetInterface(nameof(IMyInterface)) ！ = null - 但请注意 nameof 不会返回完全限定的类型名称，因此如果您在不同的命名空间中有多个命名相同的接口，您最终可能会得到所有这些

接口一个通用接口，它有点复杂：

Array.Exists(
    typeof(MyType).GetInterfaces(),
    i => i.IsGenericType
      && i.GetGenericTypeDefinition() == typeof(IMyInterface<>))

或者使用 LINQ：

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

Answer 14

使用 Type.IsAssignableFrom：

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

Answer 15

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

或者

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

Answer 16

使用 Type.IsAssignableTo（从 .NET 5.0 开始）：

typeof(MyType).IsAssignableTo(typeof(IMyInterface));

正如几条评论中所述，IsAssignableFrom 可能会因“向后”而被认为令人困惑。