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

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

使用类型。IsAssignableFrom:

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

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

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

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

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方法更安全 调用，将最终使用)。

你有几个选择:

typeof (IMyInterface) .IsAssignableFrom (typeof (MyType)) typeof (MyType) .GetInterfaces () .Contains (typeof (IMyInterface)) 在c# 6中，你可以使用typeof(MyType).GetInterface(nameof(IMyInterface)) != null

对于通用接口来说，这有点不同。

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