如何确定类型是否实现了带有C#反射的接口

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

public interface IMyInterface {}


public class MyType : IMyInterface {}


// should yield 'true'
typeof(MyType)./* ????? */MODELS_INTERFACE(IMyInterface);
300035 次浏览
小开

使用Type.IsAssignableFrom：

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));
小开 
typeof(IMyInterface).IsAssignableFrom(someclass.GetType());

或

typeof(IMyInterface).IsAssignableFrom(typeof(MyType));
小开
最佳答案

你有几个选择：

  1. typeof(IMyInterface).IsAssignableFrom(typeof(MyType))
  2. typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface))
  3. 使用C#6，您可以使用typeof(MyType).GetInterface(nameof(IMyInterface)) != null

对于通用接口，它有点不同。

typeof(MyType).GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMyInterface<>))
小开 
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. 它使用GetInterface而不是IsAssiablefrom，它更快，因为 在几次检查之后，最终会调用 获取接口。
  2. 它迭代本地数组，因此会有 没有边界检查。
  3. 它使用==运算符，该运算符定义为 类型，所以可能比Equals方法更安全（包含 调用，最终会使用）。
小开

正如其他人已经提到的： 本杰明Apr 10'13 at 22:21"

这肯定是很容易不注意和得到的论点 从后。我现在将使用GetInterface: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>();
小开

修改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);
小开

关于 

if(MyType as IMyInterface != null)

?

小开

关于什么 

typeof(IWhatever).GetTypeInfo().IsInterface
小开

我只是做了：

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心不在焉。

小开

IsAssignableFrom现在移动到TypeInfo：

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

正确答案是

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

然而， 

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

可能会返回错误的结果，如下面的字符串和IConver的代码所示：

    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
小开

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

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

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

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
}
小开

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

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

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

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

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

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

正如在一些评论中所说的，IsAssimablefrom可能会被认为是“向后”的。


提交答案