型がC＃リフレクションを備えたインターフェイスを実装しているかどうかを判断する方法

のリフレクションはC#、特定のSystem.Type型がインターフェイスをモデル化しているかどうかを判断する方法を提供しますか？

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

いくつかの選択肢があります。

1. typeof(IMyInterface).IsAssignableFrom(typeof(MyType))

2. typeof(MyType).GetInterfaces().Contains(typeof(IMyInterface))

汎用インターフェースの場合、少し異なります。

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

使用Type.IsAssignableFrom：

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

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

または

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

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

次の3つの理由から、これは正しいリリースだと思います。

1. IsAssignableFromではなくGetInterfacesを使用します。IsAssignableFromは最終的にいくつかのチェックがGetInterfacesを呼び出した後なので、より高速です。
2. ローカル配列を反復処理するため、境界チェックは行われません。
3. Typeに定義されている==演算子を使用しているため、Equalsメソッドよりも安全です（Contains呼び出しが最終的に使用します）。

今やりました：

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フリップフロップします。

最適なパフォーマンスを得るために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);

他の誰かがすでに述べたように：ベンジャミン、2013年4月10日22時21分に」

注意を払わず、IsAssignableFromの引数を逆方向に取得するのは簡単でした。今はGetInterfacesを使います：p –

さて、もう1つの方法は、「最も一般的な」考え方をある程度満たす短い拡張メソッドを作成することです（これは、個人の好みに基づいて少し「より自然」にするための非常に小さな個人的な選択であることに同意しました） ）：

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

タイプまたはインスタンスがある場合、それらが特定のインターフェースをサポートしているかどうかを簡単に確認できます。

オブジェクトが特定のインターフェースを実装しているかどうかをテストするには：

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に移動しましたTypeInfo：

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

これを検索する人は誰でも、次の拡張メソッドが便利だと思うかもしれません：

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(MyType as IMyInterface != null)

？

どうですか

typeof(IWhatever).GetTypeInfo().IsInterface

正解は

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

ジェネリックインターフェイスがある場合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<>)