Qual é o caminho mais curto para implementar um proxy ou classe decorador no c #?

Question

Quando você tem um carro classe que implementa IVehicle e você quer envolvê-la em um decorador que encaminha todas as chamadas para carro e conta-los, como você faria isso?

Em Ruby eu pudesse construir um decorador sem qualquer métodos e uso method_missing para encaminhar todas as chamadas para o objeto carro.

Em Java eu ??poderia construir um objeto proxy que executa todo o código através de um método e encaminha-lo mais tarde.

Existe alguma coisa semelhante i pode fazer em C #?

---

atualização:

com base nos answeres eo que tenho lido sobre System.Reflection.Emit deve ser possível escrever um similar método para isso:

Type proxyBuilder(Type someType, delagate functionToBeApplied, Object forward)

onde tipo implementa toda a relação de SomeType, executa functionToBeApplied e, em seguida, encaminha a chamada de método para objetos ao retornar seu retorno.

Existe alguma lib que faz exatamente isso, ou eu teria que escrever a minha própria?

Answer 1

Para proxy você pode olhar para "RealProxy" se você quiser usar os tipos padrão, é um pouco de um aborrecimento para usar embora (e que exige suas classes herdar de MarshalByRefObject).

public class TestProxy<T> : RealProxy where T : class
{
    public T Instance { get { return (T)GetTransparentProxy(); } }
    private readonly MarshalByRefObject refObject;
    private readonly string uri;

    public TestProxy() : base(typeof(T))
    {
        refObject = (MarshalByRefObject)Activator.CreateInstance(typeof(T));
        var objRef = RemotingServices.Marshal(refObject);
        uri = objRef.URI;
    }

    // You can find more info on what can be done in here off MSDN.
    public override IMessage Invoke(IMessage message)
    {
        Console.WriteLine("Invoke!");
        message.Properties["__Uri"] = uri;
        return ChannelServices.SyncDispatchMessage(message);
    }
}

Alternativamente, você pode obter "DynamicProxy" do Castelo .. Ele funciona um pouco melhor na minha experiência ..

Se você usar um daqueles que você não vai neccessarily obter grande desempenho, porém, eu utilizá-los principalmente em chamadas que provavelmente será lenta, em primeiro lugar .. Mas você pode experimentá-lo se quiser.

A solução de Marc terá melhor desempenho.

Answer 2

Infelizmente, não há suporte mixin em C #. Então você precisa para implementar todos os métodos, ou usar algum Reflection.Emit pesados ??para fazê-lo. A outra alternativa é uma classe (opcional) proxy / base de decorador ...

abstract class FooBase : IFoo {
   protected FooBase(IFoo next) {this.next = next;}
   private readonly IFoo next;
   public virtual void Bar() { // one of the interface methods
       next.Bar();
   }
   public virtual int Blop() { // one of the interface methods
       return next.Blop();
   }
   // etc
}

então

class SomeFoo : FooBase {
   public SomeFoo(IFoo next) : base(next) {}
   public override void Bar() {...}
}

Notando que o uso do FooBase é estritamente opcional; é permitido qualquer IFoo.