注意，如果你有一个通用接口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<>)

修改Jeff的答案以获得最佳性能(感谢Pierre Arnaud的性能测试):

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

查找在给定程序集中实现接口的所有类型:

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

正如其他人已经提到的: 本杰明13年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>();

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

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

它使用GetInterfaces而不是IsAssignableFrom，因为它更快 IsAssignableFrom最终在几次检查后调用 getinterface。 它遍历本地数组，所以会有 没有边界检查。 它使用为定义的==操作符 类型，因此可能比Equals方法更安全 调用，将最终使用)。

任何人搜索这个可能会发现下面的扩展方法很有用:

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

是什么

typeof(IWhatever).GetTypeInfo().IsInterface