Question

I’ve got a need to create a dynamic proxy in C#. I want this class to wrap another class, and take on it’s public interface, forwarding calls for those functions:

class MyRootClass
{
    public virtual void Foo()
    {
        Console.Out.WriteLine("Foo!");
    }

}

interface ISecondaryInterface
{
    void Bar();
}

class Wrapper<T> : ISecondaryInterface where T: MyRootClass
{
    public Wrapper(T otherObj)
    {
    }

    public void Bar()
    {
        Console.Out.WriteLine("Bar!");
    }
}

Here’s how I want to use it:

Wrapper<MyRootClass> wrappedObj = new Wrapper<MyRootClass>(new MyRootClass());
wrappedObj.Bar();
wrappedObj.Foo();

to produce:

Bar!
Foo!

Any ideas?

What’s the easiest way to do this?

What’s the best way to do this?

Thanks so much.

UPDATE

I tried following Wernight’s recommendation and implement this using C# 4.0 dynamic proxies. Unfortunately, I’m still stuck. The point of the proxy is to mimick the other interface which is (normally, usually) expected. Using DynamicObject requires me to change all the clients of this to use ‘dynamic’ instead of ‘ISecondaryInterface’.

Is there a way to get a proxy object, such that when it wraps an A, it advertises (statically?) that it supports A’s interface; and when it wraps a B, it advertises that is supports B’s interface?

UPDATE 2

For example:

class MySecretProxy : DynamicObject, ISecondaryInterface
{
    public override void TryInvokeMember(...) { .. }

    // no declaration of Bar -- let it be handled by TryInvokeMember
 }

Answer 1

.NET 4 DynamicObject can help you achieving that.

Earlier .NET framework can use:

• Aspect#
• Encase AOP
• Spring.NET
• Aspect.NET
• AspectDNG
• Dynamic Proxy
• Compose*
• Loom.NET
• PostSharp

Each of these frameworks make use of a number
techniques to the injection of code
both before and after execution of a
method. These generally fall into 4
categories.

• MSIL injection – Here we inject MSIL code into the body of the
  method being executed. (Post sharp)
• Runtime dynamic injection – Using techniques such as reflection we
  invoke methods dynamically.
• Type builder injection – Related to runtime injection, we create a type based on
  the type we wish to proxy and then marshal requests through this type. (Dynamic Proxy)
• Container injection – Requests pass through a container
  which invokes code before and after our method being executed.

See the full article.

I know that Castle Project‘s Dynamic Proxy is often used (like in Moq just to name one large project).

---

REPLY TO UPDATED TOPIC

What you wrote will not compile. Dynamic proxies are runtime generated code, so you’ll have to create a concrete instance of the class you’re proxying some way or another. May be you’re looking to do AOP (aspect-oriented programming).

class MySecretProxy<T> : DynamicObject, T where T : new()
{
    private T _instance = new T();

    public override void TryInvokeMember(...) { ... }
}

MySecretProxy<Bar> bar;