You could do this with a combination of and but you will have to have an Interface that implements the functions and properties you want to proxy.

public interface IDoStuff{    void Foo();}public class Wrapper
     
       : DynamicObject{    private readonly T _wrappedObject;    public static T1 Wrap
      
       (T obj) where T1 : class    {        if (!typeof(T1).IsInterface)            throw new ArgumentException("T1 must be an Interface");        return new Wrapper
       
        (obj).ActLike
        
         ();    }    //you can make the contructor private so you are forced to use the Wrap method.    private Wrapper(T obj)    {        _wrappedObject = obj;    }    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)    {        try        {            //do stuff here            //call _wrappedObject object            result = _wrappedObject.GetType().GetMethod(binder.Name).Invoke(_wrappedObject, args);            return true;        }        catch        {            result = null;            return false;        }    }}
        
       
      
     

You could off course choose to lose the type-safety and go with a DynamicObject like I showed and then drop the duck-casting.

I made a transparant extendible version of this object proxy, and opensourced it .