Автоматически создавая обертку для реализации интерфейса

What you're trying to accomplish, is known as duck typing. There are some dedicated libraries that will let you do that, although I haven't used any of them.

With little effort (and some reflection) you can use Castle Dynamic Proxy to do that, using approach outlined here.

If for some reason the interceptor based approach would not be acceptable for you Dynamic Proxy does not support that out of the box (yet), but if you use version 2.2 beta, it would be fairly easy to provide that in a strongly typed manner (without using interceptors), by providing your own proxy type builder (take a look at how mixins are implemented).

Если вам нужна легкая и простая поддержка набора текста Duck, вы также можете проверить: Проект Duck Typing . Он работает с .Net 2.0 и новее .

Пример использования (взят с сайта Дэвида Мейера ):

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);
    }
}

Используя методы расширения, вы можете упростить его до чего-то вроде этого ( аналог синтаксиса Барта Де Смета)

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);

You could create a new class

class SubBar : IFoo, Bar {
}

and instantiate that (Assuming Bar truly has the ducktype, i.e., the exact IFoo methods).

Вы можете посмотреть на DynamicProxy Castle Project. Это то, что Rhino.Mocks использует для проксирования своего типа.

Я не использовал его сам, поэтому не знаю, сколько усилий это потребует с вашей стороны, но я подозреваю, что это хороший отправная точка.

Взгляните на Введение в «C # Ducktaper» - мост между динамическим миром и статическим миром , поскольку это сообщение в блоге описывает именно то, что вам нужно.

Если вы хотите использовать .NET 4, решением может быть определение класса оболочки как DynamicObject и преобразование вызовов динамических методов в вызовы обернутый класс с использованием отражения (я не уверен, что это действительно потребует меньше работы; также учтите возможные проблемы с производительностью, связанные с использованием отражения).

Although I haven't used them myself I think T4 templates in Visual Studio can be used for code generation of dynamic types link text.

Вот несколько другой подход с использованием дженериков. Это потребует дополнительной работы. Вам необходимо реализовать оболочку для каждого интерфейса и вызывать все методы с отражением.

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());