Como determinar se um tipo implementa uma interface com reflexão em C #

Será reflexão em C#oferta uma maneira de determinar se alguns dados System.Typemodelos tipo algum interface?

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

Você tem poucas escolhas:

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

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

Para uma interface genérica, é um pouco diferente.

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

Use Type.IsAssignableFrom:

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

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

ou

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

Eu acho que este é o lançamento correto, por três razões:

1. Ele usa GetInterfaces e não IsAssignableFrom, é mais rápido, pois IsAssignableFrom eventualmente, depois de várias verificações, chama GetInterfaces.
2. Ele itera sobre a matriz local, portanto não haverá verificação de limites.
3. Ele usa o operador == definido para Type, portanto, provavelmente é mais seguro que o método Equals (que a chamada Contains, eventualmente usará).

Eu apenas fiz:

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

Eu gostaria de ter dito where I : interface, mas interfacenão é uma opção genérica de restrição de parâmetros. classé o mais próximo possível.

Uso:

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

Acabei de dizer Implementsporque é mais intuitivo. Eu sempre sou IsAssignableFromenganado.

Modificando a resposta de Jeff para obter o desempenho ideal (graças ao teste de desempenho de Pierre Arnaud):

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

Para encontrar todos os tipos que implementam uma interface em um dado Assembly:

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

Como alguém já mencionou: Benjamin 10 / abr / 13 às 22:21 "

Com certeza foi fácil não prestar atenção e obter os argumentos para IsAssignableFrom ao contrário. Vou agora com GetInterfaces: p -

Bem, outra maneira é apenas criar um método de extensão curto que atenda, até certo ponto, à maneira "mais usual" de pensar (e concordou que essa é uma escolha pessoal muito pequena para torná-la um pouco "mais natural" com base nas preferências de alguém ):

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

E por que não ficar um pouco mais genérico (bem, não tenho certeza se é realmente tão interessante, bem, eu suponho que estou passando outra pitada de açúcar 'sintaxe'):

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

Eu acho que pode ser muito mais natural assim, mas mais uma vez apenas uma questão de opiniões muito pessoais:

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

Se você tem um tipo ou uma instância, pode verificar facilmente se eles suportam uma interface específica.

Para testar se um objeto implementa uma certa interface:

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

Para testar se um tipo implementa uma certa interface:

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

Se você obteve um objeto genérico e deseja fazer uma conversão, bem como verificar se a interface para a qual você lança está implementada, o código é:

 var myCastedObject = myObject as IMyInterface;

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

IsAssignableFromagora é movido para TypeInfo:

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

Qualquer pessoa que procure por isso pode achar útil o seguinte método de extensão:

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

testes de unidade:

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

A respeito

if(MyType as IMyInterface != null)

?

A respeito

typeof(IWhatever).GetTypeInfo().IsInterface

Uma resposta correta é

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

Contudo,

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

pode retornar um resultado errado, como o seguinte código mostra com string e 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}");
    }

Resultados:

 isConvertibleDirect: True
 isConvertibleTypeAssignable: False
 isConvertibleHasInterface: True

Observe que se você tiver uma interface genérica IMyInterface<T>, ela sempre retornará false:

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

Isso também não funciona:

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

No entanto, se MyTypeimplementar IMyInterface<MyType>isso funciona e retorna true:

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

No entanto, você provavelmente não saberá o parâmetro type Tem tempo de execução . Uma solução um pouco hacky é:

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

A solução de Jeff é um pouco menos invasiva:

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

Aqui está um método de extensão Typeque funciona para qualquer caso:

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

(Observe que o acima usa linq, que é provavelmente mais lento que um loop.)

Você pode então fazer:

   typeof(MyType).IsImplementing(IMyInterface<>)