Як визначити, чи реалізує тип інтерфейс із відображенням 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;
}

Я думаю, що це правильний випуск з трьох причин:

1. Він використовує GetInterfaces, а не IsAssignableFrom, але це швидше, оскільки IsAssignableFrom врешті-решт після декількох перевірок викликає GetInterfaces.
2. Він повторює локальний масив, тому перевірки меж не буде.
3. Він використовує оператор ==, який визначений для типу, тому, ймовірно, безпечніший, ніж метод «Рівний» (який з часом містить виклик).

Я тільки що зробив:

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перевертаюсь.

Модифікація відповіді Джеффа для оптимальної роботи (завдяки тесту на продуктивність П'єра Арно):

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

Як уже хтось згадував: Бенджамін 10 квітня 1313 о 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>();

Якщо у вас є тип або екземпляр, ви можете легко перевірити, чи підтримують вони певний інтерфейс.

Щоб перевірити, чи об’єкт реалізує певний інтерфейс:

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