c# - que - Implementaciones de interfaz a través de Reflection

que es una interfaz en programacion

Question

¿Cómo puedo obtener todas las implementaciones de una interfaz a través de la reflexión en C #?

Answer 1

¿Te refieres a todas las interfaces que implementa un Type?

Me gusta esto:

ObjX foo = new ObjX();
Type tFoo = foo.GetType();
Type[] tFooInterfaces = tFoo.GetInterfaces();
foreach(Type tInterface in tFooInterfaces)
{
  // do something with it
}

Espero que ayude.

Answer 2

Aquí hay algunos métodos de extensión de Type que pueden ser útiles para esto, como sugiere Simon Farrow . Este código es solo una reestructuración de la respuesta aceptada.

Código

/// <summary>
/// Returns all types in <paramref name="assembliesToSearch"/> that directly or indirectly implement or inherit from the given type. 
/// </summary>
public static IEnumerable<Type> GetImplementors(this Type abstractType, params Assembly[] assembliesToSearch)
{
    var typesInAssemblies = assembliesToSearch.SelectMany(assembly => assembly.GetTypes());
    return typesInAssemblies.Where(abstractType.IsAssignableFrom);
}

/// <summary>
/// Returns the results of <see cref="GetImplementors"/> that match <see cref="IsInstantiable"/>.
/// </summary>
public static IEnumerable<Type> GetInstantiableImplementors(this Type abstractType, params Assembly[] assembliesToSearch)
{
    var implementors = abstractType.GetImplementors(assembliesToSearch);
    return implementors.Where(IsInstantiable);
}

/// <summary>
/// Determines whether <paramref name="type"/> is a concrete, non-open-generic type.
/// </summary>
public static bool IsInstantiable(this Type type)
{
    return !(type.IsAbstract || type.IsGenericTypeDefinition || type.IsInterface);
}

Ejemplos

Para obtener los implementadores de instancia en el conjunto de llamada:

var callingAssembly = Assembly.GetCallingAssembly();
var httpModules = typeof(IHttpModule).GetInstantiableImplementors(callingAssembly);

Para obtener los implementadores en el AppDomain actual:

var appDomainAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var httpModules = typeof(IHttpModule).GetImplementors(appDomainAssemblies);

Answer 3

Debe recorrer todos los ensamblados que le interesen. Desde el ensamblado puede obtener todos los tipos que define. Tenga en cuenta que cuando hace AppDomain.CurrentDomain.Assemblies solo obtiene los ensamblados que están cargados. Los ensamblajes no se cargan hasta que se necesiten, por lo que debe cargar explícitamente los ensamblajes antes de comenzar la búsqueda.

Answer 4

Eche un vistazo al método Assembly.GetTypes() . Devuelve todos los tipos que se pueden encontrar en un ensamblaje. Todo lo que tiene que hacer es iterar a través de cada tipo devuelto y verificar si implementa la interfaz necesaria.

En el camino para hacerlo está utilizando el método Type.IsAssignableFrom .

Aquí está el ejemplo. myInterface es la interfaz cuyas implementaciones está buscando.

Assembly myAssembly;
Type myInterface;
foreach (Type type in myAssembly.GetTypes())
{
    if (myInterface.IsAssignableFrom(type))
        Console.WriteLine(type.FullName);
}

Creo que no es una forma muy eficiente de resolver su problema, pero al menos es un buen lugar para comenzar.

Answer 5

La respuesta es esta; busca en todo el dominio de la aplicación, es decir, cada ensamblaje cargado actualmente por su aplicación.

/// <summary>
/// Returns all types in the current AppDomain implementing the interface or inheriting the type. 
/// </summary>
public static IEnumerable<Type> TypesImplementingInterface(Type desiredType)
{
    return AppDomain
           .CurrentDomain
           .GetAssemblies()
           .SelectMany(assembly => assembly.GetTypes())
           .Where(type => desiredType.IsAssignableFrom(type));
}

Se usa así;

var disposableTypes =  TypesImplementingInterface(typeof(IDisposable));

También puede desear que esta función encuentre tipos de concreto reales, es decir, que filtren resúmenes, interfaces y definiciones de tipos genéricos.

public static bool IsRealClass(Type testType)
{
    return testType.IsAbstract == false
         && testType.IsGenericTypeDefinition == false
         && testType.IsInterface == false;
}

Answer 6

Assembly assembly = Assembly.GetExecutingAssembly();
List<Type> types = assembly.GetTypes();
List<Type> childTypes = new List<Type>();
foreach (Type type in Types) {
  foreach (Type interfaceType in type.GetInterfaces()) {
       if (interfaceType.Equals(typeof([yourinterfacetype)) {
            childTypes.Add(type)
            break;
       }
  }
}

Tal vez algo así ...