Hacer que el objeto implemente dinámicamente una interfaz en el código

Question

Quiero hacer que este pase de prueba, ¿alguien tuvo una idea de cómo hacerlo?

public class Something 
{ 
    public string Name {get; set} 
} 

public interface IWithId 
{ 
    public Guid Id {get; set} 
} 

public class IdExtender 
{ 
    public static Object Extend(object toExtend) 
    { 
     ...? 
    } 
} 

public class Tests 
{ 
    [Test] 
    public void Should_extend_any_object() 
    { 
     var thing = new Something { Name = "Hello World!"}; 
     var extended = IdExtender.Extend(thing); 
     Assert.IsTrue(extended is IWithId); 
     Assert.IsTrue(extended.Id is Guid); 
     Assert.IsTrue(extened.Name == "Hello World!"); 
    } 
} 

supongo que algo como esto se podría hacer con Proxy castillo dinámico, Linfu, etc ... pero ¿cómo?

Answer 1

Usando Castillo DP (obviamente)

Bien - usted tendrá que crear un nuevo objeto de volver ya que no puede tener un tipo existente ganar una nueva interfaz como su programa se está ejecutando.

Para hacer esto, necesitará crear un proxy y luego replicar el estado de su objeto preexistente en el proxy. DP no hace eso OOTB. En v2.5, podría usar el nuevo proxy de clase con destino, pero eso solo funcionaría si todas las propiedades del tipo fueran virtuales.

De todos modos. Puede hacer que el nuevo tipo gane la interfaz IWithId mezclando el proxy con un objeto existente que implemente la propiedad. Luego, las llamadas a los miembros de la interfaz se reenviarán al objeto.

Como alternativa, puede proporcionarlo como una interfaz adicional para implementar y tener un interceptor que complete el rol de implementador.

Answer 2

¿Por qué no utilizar un mocking framework like Moq o RhinoMocks. Le permiten implementar interfaces dinámicamente sin la dificultad de crear un proxy directamente.

Con Moq se podría escribir:

var mock = new Mock<IWithId>(); // mock the interface 
mock.Setup(foo => foo.Name).Returns("Hello World"); // setup a property 

Aparte de eso, usted tendría que hacer un trabajo complicado para conseguir lo que desea. Por lo que yo sé, no puede agregar método o propiedades a una clase existente en tiempo de ejecución. Podría devolver una instancia de un nuevo objeto que hereda dinámicamente del tipo pasado. Castle definitivamente permite esto, pero el código necesario no es especialmente elegante o simple.

Answer 3

Dejando a un lado la cuestión de cómo adjuntar dinámicamente una propiedad o interfaz, parece que lo que está intentando hacer es aumentar las clases existentes con datos adicionales. Una solución muy típica a este problema es usar un Dictionary<Something, SomethingExtra> y almacenarlo en alguna clase de servicio que mantenga la asignación. Ahora, cuando necesite acceder a SomethingExtra, simplemente solicite a la clase de servicio la información asociada.

Ventajas:

1. La aplicación es fácil de entender y de mantener que una solución mediante la reflexión y la generación de proxy dinámico.

2. Si necesita derivar del tipo extendido, la clase no se puede sellar. Asociar información externamente funciona bien con clases selladas.

3. Puede asociar información sin tener que ser responsable de la construcción del objeto aumentado. Puede tomar instancias creadas en cualquier lugar y asociar la nueva información.

Desventajas:

1. que necesita inyectarse la instancia de servicio que mantiene la asignación. Puedes hacerlo a través de un framework IoC si estás usando uno, inyección manual (generalmente pasa a través de un constructor) o, si no hay otra alternativa, a través de un acceso directo estático de Singleton.

2. Si tiene un gran número de instancias y se están creando/eliminando rápidamente, la sobrecarga del diccionario podría ser notable. Sospecho que necesitarías una carga muy pesada antes de que la sobrecarga se note en comparación con una implementación de proxy.

Answer 4

Por ahora voy con Linfu así:

public class IdExtender 
{ 
    public static Object Extend(object toExtend) 
    { 
     var dyn = new DynamicObject(toExtend); 
     dyn.MixWith(new WithId { 
           Id = Guid.New() 
           }); 
     var extended = dyn.CreateDuck<IWithId>(returnValue.GetType().GetInterfaces()); 
     return extended; 
    } 
} 

Answer 5

De hecho, me han contestado a la semana pasada similar question. También he escrito una pequeña biblioteca que hace esto. Está disponible en mi blog, que estoy enchufado descaradamente.

Lo que está buscando es casi posible con Castle Dynamic Proxy. La única restricción es que la instancia existente debe implementar una interfaz y todas las propiedades/métodos que le interesan están disponibles a través de esa interfaz.

public static TIntf CreateMixinWithTarget<TIntf>(TIntf target, params object[] instances) where TIntf : class{ 

    ProxyGenerator generator = new ProxyGenerator(); 
    ProxyGenerationOptions options = new ProxyGenerationOptions(); 

    instances.ToList().ForEach(obj => options.AddMixinInstance(obj)); 

    return generator.CreateInterfaceProxyWithTarget <TIntf>(target, options); 
} 

[Test] 
public void Should_extend_any_object() 
{ 
    var thing = new Something { Name = "Hello World!"}; 
    var extended = CreateMixinWithTarget<ISomething>(thing, new WithId(), new GuidImpl()); 
    Assert.IsTrue(extended is IWithId); 
    Assert.IsTrue(extended.Id is Guid); 
    Assert.IsTrue(extened.Name == "Hello World!"); 
}