¿Cómo encontrar todas las clases que implementan una interfaz determinada?

Question

Bajo un espacio de nombres dado, tengo un conjunto de clases que implementan una interfaz. Vamos a llamarlo ISomething. Tengo otra clase (llamémoslo CClass) que conoce aproximadamente ISomething pero no conoce las clases que implementan esa interfaz.

Me gustaría que CClass busque toda la implementación de ISomething, cree una instancia de la instancia y ejecute el método.

¿Alguien tiene una idea de cómo hacer eso con C# 3.5?

Answer 1

un código de muestra de trabajo:

var instances = from t in Assembly.GetExecutingAssembly().GetTypes() 
       where t.GetInterfaces().Contains(typeof(ISomething)) 
         && t.GetConstructor(Type.EmptyTypes) != null 
       select Activator.CreateInstance(t) as ISomething; 

foreach (var instance in instances) 
{ 
    instance.Foo(); // where Foo is a method of ISomething 
} 

Editar añadido un cheque por un constructor sin parámetros para que la llamada a CreateInstance tendrá éxito.

Answer 2

Un ejemplo usando LINQ:

var types = 
    myAssembly.GetTypes() 
      .Where(m => m.IsClass && m.GetInterface("IMyInterface") != null); 

Answer 3

usted podría utilizar algo como lo siguiente y adaptarlo a sus necesidades.

var _interfaceType = typeof(ISomething); 
var currentAssembly = System.Reflection.Assembly.GetExecutingAssembly(); 
var types = GetType().GetNestedTypes(); 

foreach (var type in types) 
{ 
    if (_interfaceType.IsAssignableFrom(type) && type.IsPublic && !type.IsInterface) 
    { 
     ISomething something = (ISomething)currentAssembly.CreateInstance(type.FullName, false); 
     something.TheMethod(); 
    } 
} 

Este código podría utilizar algunas mejoras de rendimiento, pero es un comienzo.

Answer 4

Usted puede obtener una lista de ensamblados cargados mediante el uso de esto:

Assembly assembly = System.Reflection.AppDomain.CurrentDomain.GetAssemblies() 

A partir de ahí, se puede obtener una lista de tipos en la asamblea (asumiendo tipos públicos):

Type[] types = assembly.GetExportedTypes(); 

Entonces puede preguntar a cada tipo si es compatible con esa interfaz al encontrar esa interfaz en el objeto:

Type interfaceType = type.GetInterface("ISomething"); 

No estoy seguro de si hay una manera más eficiente de hacer esto con la reflexión.

Answer 5

foreach (Type t in Assembly.GetCallingAssembly().GetTypes()) 
{ 
    if (t.GetInterface("ITheInterface") != null) 
    { 
     ITheInterface executor = Activator.CreateInstance(t) as ITheInterface; 
     executor.PerformSomething(); 
    } 
} 

Answer 6

Tal vez deberíamos ir por este camino

foreach (var instance in Assembly.GetExecutingAssembly().GetTypes().Where(a => a.GetConstructor(Type.EmptyTypes) != null).Select(Activator.CreateInstance).OfType<ISomething>()) 
    instance.Execute();