使用类型。IsAssignableTo(自。net 5.0起):

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

正如在一些评论中所述，IsAssignableFrom可能被认为是“向后”的混淆。

如果您有一个类型或实例，您可以很容易地检查它们是否支持特定的接口。

测试一个对象是否实现了某个接口:

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
    }

使用类型。IsAssignableFrom:

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

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

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

注意，如果你有一个通用接口IMyInterface<T>，那么这个将总是返回false:

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

这也不管用:

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

然而，如果MyType实现了IMyInterface<MyType>，这将工作并返回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<>)

是什么

typeof(IWhatever).GetTypeInfo().IsInterface