Cómo determinar si un tipo implementa una interfaz con reflexión C #

Qué reflexión en C#ofrecer una manera de determinar si algunos dados System.Typemodelos tipo de alguna de las interfaces?

public interface IMyInterface {}

public class MyType : IMyInterface {}

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

Tienes algunas opciones:

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

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

Para una interfaz genérica, es un poco diferente.

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

Uso Type.IsAssignableFrom:

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

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

o

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

Creo que esta es la versión correcta, por tres razones:

1. Utiliza GetInterfaces y no IsAssignableFrom, es más rápido ya que IsAssignableFrom finalmente después de varias comprobaciones llama a GetInterfaces.
2. Se itera sobre la matriz local, por lo que no habrá verificaciones de límites.
3. Utiliza el operador == que está definido para Tipo, por lo que probablemente sea más seguro que el método Equals (que la llamada Contiene, eventualmente usará).

Lo acabo de hacer:

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

Desearía haberlo dicho where I : interface, pero interfaceno es una opción genérica de restricción de parámetros. classestá lo más cerca posible.

Uso:

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

Solo dije Implementsporque eso es más intuitivo. Siempre me IsAssignableFromflip-flop.

Modificación de la respuesta de Jeff para un rendimiento óptimo (gracias a la prueba de rendimiento de Pierre Arnaud):

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

Para buscar todos los tipos que implementan una interfaz en un determinado Assembly:

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

Como alguien más ya mencionó: Benjamin Abr 10 '13 a las 22:21 "

Seguro que fue fácil no prestar atención y obtener los argumentos para IsAssignableFrom al revés. Iré con GetInterfaces ahora: p -

Bueno, otra forma de evitarlo es crear un método de extensión breve que cumpla, hasta cierto punto, la forma de pensar "más habitual" (y acordó que esta es una elección personal muy pequeña para que sea un poco "más natural" en función de las preferencias personales) ):

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

¿Y por qué no ser un poco más genérico?

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

Creo que podría ser mucho más natural de esa manera, pero una vez más solo es cuestión de opiniones muy personales:

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

Si tiene un tipo o una instancia, puede verificar fácilmente si son compatibles con una interfaz específica.

Para probar si un objeto implementa una determinada interfaz:

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

Para probar si un tipo implementa una determinada interfaz:

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

Si tiene un objeto genérico y desea realizar una conversión, así como verificar si la interfaz a la que está implementado, el código es:

 var myCastedObject = myObject as IMyInterface;

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

IsAssignableFromahora se mueve a TypeInfo:

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

Cualquiera que busque esto puede encontrar útil el siguiente método de extensión:

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

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

qué pasa

if(MyType as IMyInterface != null)

?

Qué pasa

typeof(IWhatever).GetTypeInfo().IsInterface

Una respuesta correcta es

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

Sin embargo,

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

podría devolver un resultado incorrecto, como se muestra en el siguiente código con 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

Tenga en cuenta que si tiene una interfaz genérica IMyInterface<T>, esto siempre devolverá false:

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

Esto tampoco funciona:

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

Sin embargo, si MyTypeimplementa IMyInterface<MyType>esto funciona y devuelve true:

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

Sin embargo, es probable que no conozca el parámetro de tipo Ten tiempo de ejecución . Una solución algo hacky es:

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

La solución de Jeff es un poco menos hacky:

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

Aquí hay un método de extensión Typeque funciona para cualquier 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);
    }
}

(Tenga en cuenta que lo anterior usa linq, que probablemente es más lento que un bucle).

Entonces puedes hacer:

   typeof(MyType).IsImplementing(IMyInterface<>)