C# ¿Cómo generar un objeto implementando diferentes interfaces dinámicamente en tiempo de ejecución?

Question

estoy mirando a la forma de resolver un problema y no estoy siquiera seguro de que esto podría ser posible en absoluto en C# .NET 3.5 &:

Decir que tengo un número limitado de interfaces, cada uno que describe un procedimiento específico, conjunto de métodos no relacionados. Ahora tengo un número de dispositivos del mundo real en los que cada uno puede implementar solo un subconjunto de estas interfaces.

Durante la configuración de las comunicaciones con estos dispositivos, ellos me dirán qué capacidades tienen. Ahora me gustaría crear un objeto que implementa las interfaces (cada uno se asemeja a una capacidad del dispositivo) de manera que más arriba en mi arquitectura de aplicaciones soy capaz de:

• código de escritura contra las interfaces mencionadas
• prueba si ese objeto generado implementa una cierta interfaz para ver si se admiten ciertas acciones

No estoy seguro de qué enfoque utilizar para este problema. ¡Cualquier comentario o enfoque es bienvenido!

Answer 1

Pruebe algo como LinFu.DynamicObject.

Answer 2

Utilice un mocking framework como Moq, RhinoMocks o TypeMock Isolator

Si usted está buscando para hacer algo de nivel inferior, cosas como Castle DynamicProxy podría ser una buena dirección para usted.

Answer 3

Es posible, simplemente no es fácil. Necesita crear una cadena que sea básicamente un archivo fuente y luego crear y usar un CSharpCodeProvider, que luego ordena compilar. Si funciona, puedes acceder manualmente a tus objetos creados a través de la reflexión.

Para el interesado, lo hice hace un tiempo, los detalles son un poco brumosos.

Answer 4

Quizás no necesite hacer esto tan "dinámico".

¿Has comprobado el patrón Abstract Factory? Parece que básicamente lo que necesita es crear una implementación concreta para cada una de sus interfaces basada en un dispositivo tipo.

No necesita tener una única clase que implemente muchas interfaces, es suficiente con la implementación adecuada de la interfaz específica cuando su código lo solicite.

Cada implementación concreta de su fábrica abstracta puede generar varias implementaciones de interfaz en función de su tipo de dispositivo.

Ejemplo:

public interface IDeviceFactory 
{ 
     ISomething GetSomeInterface(); 
     ISomethingElse GetSomeOtherInterface(); 
} 

y luego se implementa la fábrica específica para cada dispositivo:

public class SimpleDeviceFactory : IDeviceFactory 
{ 
    public virtual ISomething GetSomeInterface() 
    { return Something.Empty; } 

    public virtual ISomethingElse GetSomeOtherInterface() 
    { return new SomeSimpleConreteImplementation(); } 
} 

o tal vez:

public class ComplexDeviceFactory : IDeviceFactory 
{ 
    public virtual ISomething GetSomeInterface() 
    { return new ComplexStuff(); } 

    public virtual ISomethingElse GetSomeOtherInterface() 
    { return new EvenMoreComplexStuff(); } 
} 

Y luego, finalmente, se crea la derecha fábrica para su dispositivo:

public class DeviceFactory 
{ 
    public static IDeviceFactory CreateForDevice(IDevice device) 
    { 
      DeviceType type = device.Type; // or something like this 
      switch (type) 
      { 
       case DeviceType.Simple: 
       return new SimpleDeviceFactory(); 

       case DeviceType.Complex: 
       return new ComplexDeviceFactory(); 

       default: 
       throw new NotImplementedException(); 
      } 
    } 
} 

Tenga en cuenta que también he marcado las implementaciones del método IDeviceFactory como virtual, por lo que puede reutilizar o anular fácilmente interfaces específicas para un dispositivo específico.

Answer 5

.NET 4 podría hacerlo más fácil, puede usar uno de los marcos ya mencionados o seguir la ruta System.Reflection. Encontrará muchas muestras en internet.

He hecho ambas cosas en el pasado. Lanzando mi propio il.Emit cosas y usando un marco (Spring.NET en mi caso). Para cualquier cosa que no sea trivial, use uno de los marcos.

Answer 6

También puedes probar con el proyecto Re-mix. Una de las características principales de este proyecto es crear mixins, que le permite agregar interfaces con implementaciones y estado a otras clases. Echar un vistazo este ejemplo:

using Remotion.Mixins; 
using Remotion.TypePipe; 
//... 

public interface ITargetInterface 
{ 
    void DoSomething(); 
} 
// . . . 
public class TargetImplementation : ITargetInterface 
{ 
    public void DoSomething() 
    { 
     Console.WriteLine("ITargetInterface.DoSomething()"); 
    } 
} 
// . . . 
public interface IMixinInterfaceA 
{ 
    void MethodA(); 
} 
// . . . 
public class MixinImplementationA : IMixinInterfaceA 
{ 
    public void MethodA() 
    { 
     Console.WriteLine("IMixinInterfaceA.MethodA()"); 
    } 
} 
// . . . 
public interface IMixinInterfaceB 
{ 
    void MethodB(int parameter); 
} 

// . . . 
public class MixinImplementationB : IMixinInterfaceB 
{ 
    public void MethodB(int parameter) 
    { 
     Console.WriteLine("IMixinInterfaceB.MethodB({0})", parameter); 
    } 
} 

A continuación, puede combinar estos tipos para crear un mixin:

var config = MixinConfiguration.BuildFromActive() 
      .ForClass<TargetImplementation>() 
      .AddMixin<MixinImplementationA>() 
      .AddMixin<MixinImplementationB>() 
      .BuildConfiguration(); 
MixinConfiguration.SetActiveConfiguration(config); 

Por desgracia, no se puede simplemente llamar nuevo en el TargetImplementation y esperar un mixin. En su lugar, debe pedirle a Re-mix que cree una instancia de TargetImplementation para que pueda crear un nuevo tipo para su especificación y crear una instancia. Cuando se le pida una instancia de TargetImplementation, devolverá un mixin que contiene todas las interfaces y clases combinadas.

ITargetInterface target = ObjectFactory.Create<TargetImplementation>(ParamList.Empty); 

target.DoSomething(); 

var targetAsMixinA = target as IMixinInterfaceA; 
if (targetAsMixinA != null) 
{ 
    targetAsMixinA.MethodA(); 
} 

var targetAsMixinB = target as IMixinInterfaceB; 
if (targetAsMixinB != null) 
{ 
    targetAsMixinB.MethodB(30); 
}