Creación automática de un contenedor para implementar una interfaz

Question

Tengo algunas clases que no implementan una determinada interfaz pero cumplen estructuralmente con esa interfaz.

interface IFoo { 
    void method(); 
} 

class Bar { // does not implement IFoo 
    public void method() {...} 
} 

Ahora, podría escribir una envoltura alrededor de aquellas clases que simplemente delegan a la clase envuelta

class BarWrapper : IFoo { 
    Bar bar = new Bar(); 
    public void method() 
    { 
     bar.method(); 
    } 
} 

Pero eso es un montón de trabajo tedioso. ¿Pueden esas clases contenedoras generarse automáticamente? Algo así como:

IFoo foo = CreateWrapper<IFoo>(new Bar());

Estoy seguro de que podría hacer esto con Reflection.Emit pero nunca he utilizado y que no se ve muy fácil a primera vista.

¿Hay una manera más fácil o quizás hay una biblioteca que ya implementa esto?

Answer 1

Es posible que desee ver Castle Project DynamicProxy. Eso es lo que Rhino.Mocks usa para su tipo de proxying.

No lo he usado, por lo que no sé cuánto esfuerzo requerirá de su parte, pero sospecho que es un buen punto de partida.

Answer 2

Si está dispuesto a usar .NET 4, una solución podría ser definir la clase contenedora como DynamicObject y convertir las llamadas a los métodos dinámicos en llamadas a la clase envuelta mediante el uso de la reflexión (no estoy seguro si eso realmente sería menos trabajo, de todos modos, también tomar en cuenta las posibles preocupaciones de rendimiento asociadas al uso de la reflexión).

Answer 3

Eche un vistazo a Introducing “The C# Ducktaper” – Bridging the dynamic world with the static world ya que esta publicación del blog describe exactamente lo que necesita.

Answer 4

Aunque no las he usado yo mismo, creo que las plantillas T4 en Visual Studio se pueden usar para la generación de código de tipos dinámicos link text.

Answer 5

Aquí hay un enfoque ligeramente diferente al usar genéricos. Esto necesitaría un poco más de pensamiento de trabajo. Debe implementar un contenedor para cada interfaz y llamar a todos los métodos con reflexión.

class FooWrapper<T> : IFoo 
{ 
    private T obj; 

    public FooWrapper(T obj) 
    { 
     this.obj = obj; 
    } 

    public void method() 
    { 
     // call method with reflection 
     // obj.method(); 
    } 
} 

IFoo foo = new FooWrapper(new Bar()); 

Answer 6

Lo que estás tratando de lograr, se conoce como pato de tipeo. Hay algunas bibliotecas dedicadas que te permitirán hacer eso, aunque no he usado ninguna de ellas.

Con poco esfuerzo (y algo de reflexión) puede usar Castle Dynamic Proxy para hacer eso, utilizando el enfoque descrito here.

Si por alguna razón el enfoque basado en interceptor no fuera aceptable para usted, Dynamic Proxy no lo admite de inmediato (pero), pero si utiliza la versión 2.2 beta, sería bastante fácil proporcionar eso en una manera fuertemente tipada (sin usar interceptores), al proporcionar su propio generador de tipo de proxy (observe cómo se implementan las mezclas).

Answer 7

Se puede crear una nueva clase

class SubBar : IFoo, Bar { 
} 

y cree una instancia que (Suponiendo Bar verdaderamente tiene el ducktype, es decir,, los métodos exactos IFoo).

Answer 8

Si quiere un soporte de tipado simple y ligero, también puede visitar: Duck Typing project. Funciona con .Net 2.0 y más reciente.

Ejemplo de uso (tomado de David Meyer's site):

public interface ICanAdd 
{ 
    int Add(int x, int y); 
} 

// Note that MyAdder does NOT implement ICanAdd, 
// but it does define an Add method like the one in ICanAdd: 
public class MyAdder 
{ 
    public int Add(int x, int y) 
    { 
     return x + y; 
    } 
} 

public class Program 
{ 
    void Main() 
    { 
     MyAdder myAdder = new MyAdder(); 

     // Even though ICanAdd is not implemented by MyAdder, 
     // we can duck cast it because it implements all the members: 
     ICanAdd adder = DuckTyping.Cast<ICanAdd>(myAdder); 

     // Now we can call adder as you would any ICanAdd object. 
     // Transparently, this call is being forwarded to myAdder. 
     int sum = adder.Add(2, 2); 
    } 
} 

El uso de métodos de extensión, que podría simplificar en algo como esto (simlar a Bart De Smet's sintaxis)

MyAdder myAdder = new MyAdder(); // this doesn't implement the interface 
ICanAdd adder = myAdder.AsIf<ICanAdd>(); // but it quacks like a duck 
int sum = adder.Add(2, 2);