Cara menentukan apakah suatu tipe mengimplementasikan antarmuka dengan refleksi C #

Apakah refleksi dalam C#menawarkan cara untuk menentukan apakah beberapa System.Typemodel yang diberikan beberapa antarmuka?

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

Anda punya beberapa pilihan:

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

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

Untuk antarmuka generik, ini sedikit berbeda.

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

Gunakan Type.IsAssignableFrom:

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

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

atau

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

Saya pikir ini adalah rilis yang benar, karena tiga alasan:

1. Ia menggunakan GetInterfaces dan bukan IsAssignableFrom, lebih cepat karena IsAssignableFrom akhirnya setelah beberapa pemeriksaan memanggil GetInterfaces.
2. Itu beralih ke array lokal, sehingga tidak akan ada batas pemeriksaan.
3. Ia menggunakan operator == yang didefinisikan untuk Tipe, jadi mungkin lebih aman daripada metode Persamaan (yang panggilan Contains, akhirnya akan gunakan).

Saya baru saja melakukannya:

public static bool Implements<I>(this Type source) where I : class
{
  return typeof(I).IsAssignableFrom(source);
}

Saya berharap saya bisa mengatakan where I : interface, tetapi interfacebukan opsi kendala parameter generik. classsedekat yang didapatnya.

Pemakaian:

if(MyType.Implements<IInitializable>())
  MyCollection.Initialize();

Saya hanya mengatakan Implementskarena itu lebih intuitif. Saya selalu IsAssignableFromjungkir balik.

Memodifikasi jawaban Jeff untuk kinerja optimal (berkat tes kinerja oleh Pierre Arnaud):

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

Untuk menemukan semua jenis yang mengimplementasikan antarmuka dalam yang diberikan Assembly:

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

Seperti yang telah disebutkan orang lain: Benjamin 10 Apr '13 pada 22:21 "

Memang mudah untuk tidak memperhatikan dan mendapatkan argumen untuk IsAssignableFrom mundur. Saya akan pergi dengan GetInterfaces sekarang: p -

Nah, cara lain adalah menciptakan metode ekstensi pendek yang memenuhi, sampai batas tertentu, cara berpikir "paling umum" (dan sepakat bahwa ini adalah pilihan pribadi yang sangat sedikit untuk menjadikannya sedikit "lebih alami" berdasarkan preferensi seseorang. ):

public static class TypeExtensions
{
    public static bool IsAssignableTo(this Type type, Type assignableType)
    {
        return assignableType.IsAssignableFrom(type);
    }
}

Dan mengapa tidak menjadi sedikit lebih generik (yah tidak yakin apakah itu benar-benar semenarik itu, saya kira saya hanya melewatkan sedikit gula 'sintaksis'):

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

Saya pikir itu mungkin jauh lebih alami seperti itu, tetapi sekali lagi hanya masalah pendapat yang sangat pribadi:

var isTrue = michelleType.IsAssignableTo<IMaBelle>();

Jika Anda memiliki tipe atau instance, Anda dapat dengan mudah memeriksa apakah mereka mendukung antarmuka tertentu.

Untuk menguji apakah suatu objek mengimplementasikan antarmuka tertentu:

if(myObject is IMyInterface) {
  // object myObject implements IMyInterface
}

Untuk menguji apakah suatu tipe mengimplementasikan antarmuka tertentu:

if(typeof(IMyInterface).IsAssignableFrom(typeof(MyType))) {
  // type MyType implements IMyInterface
}

Jika Anda mendapatkan objek generik dan ingin melakukan pemeran serta memeriksa apakah antarmuka yang Anda gunakan untuk mengimplementasikan kode tersebut adalah:

 var myCastedObject = myObject as IMyInterface;

    if(myCastedObject != null) {
      // object myObject implements IMyInterface
    }

IsAssignableFromsekarang dipindahkan ke TypeInfo:

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

Siapa pun yang mencari ini mungkin menemukan metode ekstensi berikut berguna:

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

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

bagaimana dengan

if(MyType as IMyInterface != null)

?

Bagaimana dengan

typeof(IWhatever).GetTypeInfo().IsInterface

Jawaban yang benar adalah

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

Namun,

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

mungkin mengembalikan hasil yang salah, seperti yang ditunjukkan kode berikut dengan string dan 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}");
    }

Hasil:

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True

Perhatikan bahwa jika Anda memiliki antarmuka generik IMyInterface<T>maka ini akan selalu kembali false:

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

Ini juga tidak bekerja:

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

Namun, jika MyTypemengimplementasikan IMyInterface<MyType>ini berhasil dan mengembalikan true:

  typeof(IMyInterface<MyType>).IsAssignableFrom(typeof(MyType))

Namun, Anda mungkin tidak akan tahu parameter tipe Tsaat runtime . Solusi yang agak rumit adalah:

  typeof(MyType).GetInterfaces()
                .Any(x=>x.Name == typeof(IMyInterface<>).Name)

Solusi Jeff sedikit kurang rapi:

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

Berikut adalah metode ekstensi Typeyang berfungsi untuk kasus apa pun:

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

(Perhatikan bahwa di atas menggunakan linq, yang mungkin lebih lambat dari satu loop.)

Anda kemudian dapat melakukan:

   typeof(MyType).IsImplementing(IMyInterface<>)