如何在 C# 中制作一个简单的动态代理

Question

我想构建一个动态代理对象来为对象添加某些功能。

基本上我想接收一个对象，用一个看起来与我得到的原始对象相同的对象包装它，然后拦截所有调用。

class Wrapper : DynamicProxy// dynamic proxy is not a reall class, but i guess something like this exists...
{
    public static T Wrap(T obj)
    {
        return (T) new Wrapper(obj);
    }

    public override object InterceptCall(MethodInfo info, object[] args)
    {
        // do stuff
    }

}

---

澄清一下，我想做一些类似于 WCF 通道工厂的事情...

---

我正在添加赏金，因为我需要一种代理类（而不是接口）和处理非虚拟方法的好方法（就像我在“new”关键字下继承并添加了一个方法一样）。 我确信这一切都是 .Net 实现的。

Answer 1

看看PostSharp。 我不知道在 vanilla .Net 中做你想做的事情的方法，但是 PostSharp 提供了诸如“OnMethodBoundaryAspect”之类的东西，可以用来替换或包装方法内的代码。

我用它来做一些事情，比如日志记录、参数验证、异常处理等。

有一个免费的社区版，应该适合您。您需要将它安装在您的开发机器以及您使用的任何构建服务器上。

Answer 2

您可以使用DynamicObject 和ImpromptuInterface 的组合来执行此操作，但您必须有一个接口来实现您要代理的功能和属性。

public interface IDoStuff
{
    void Foo();
}

public class Wrapper<T> : DynamicObject
{
    private readonly T _wrappedObject;

    public static T1 Wrap<T1>(T obj) where T1 : class
    {
        if (!typeof(T1).IsInterface)
            throw new ArgumentException("T1 must be an Interface");

        return new Wrapper<T>(obj).ActLike<T1>();
    }

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

您当然可以选择失去类型安全性并像我展示的那样使用DynamicObject，然后放弃鸭子铸造。

我制作了这个对象代理的透明可扩展版本，并将其开源here。

Answer 3

Github上除了Castle.DynamicProxy，还有LinFu.DynamicProxy。

Answer 4

另一个选项是ContextBoundObject。

大约 8-9 年前有一篇关于 CodeProject 的文章使用这种方法来跟踪方法调用。

Answer 5

我应该早点写这个，但没关系。

我的问题有一个特殊的“陷阱”，我需要能够代理类而不是接口。

有两种解决方案：

1. RealProxy 和朋友们，基本上是指使用.NET Remoting。需要一个继承自ContextBoundObject。

   • 这种方法利用了 .NET JIT 编译器提供的“魔法” (which is hardcoded to specifically recognize RealProxy) 让您“覆盖”非虚拟成员。

2. 使用System.Reflection.Emit 构建代理，正如spring 所做的那样，您还可以查看他们的ProxyFactoryObject 的代码。这里是another 三个articles subject。

   • 这种方法的一个关键缺点是限制您只能覆盖 virtual 成员。

Answer 6

要在类中的每个函数之前和之后添加任何功能，Real proxy 是一个不错的方法。

所以现在在 T 中可以是任何 TestClass。像这样为TestClass创建实例-

var _instance=(object)DynamicProxy(TestClass).GetTransparentProxy();

动态代理的代码-

 class DynamicProxy<T> : RealProxy
    {
        readonly T decorated;

        public DynamicProxy(T decorated) : base(typeof(T))
        {
            this.decorated = decorated;
        }

        public override IMessage Invoke(IMessage msg)
        {
            var methodCall = msg as IMethodCallMessage;
            var methodInfo = methodCall.MethodBase as MethodInfo;
            string fullMethodName = $"{methodInfo.DeclaringType.Name}.{methodCall.MethodName}";

            try
            {
                var result = methodInfo.Invoke(decorated, methodCall.InArgs);

                return new ReturnMessage(result, null, 0, methodCall.LogicalCallContext, methodCall);
            }

            catch (Exception e)
            {
                return new ReturnMessage(e, methodCall);
            }
            finally
            {
            }
        }
    }

Answer 7

除非您让 CLR 挂钩到对该对象的每个方法/属性调用并将调用重定向到您创建的假对象，否则您无法拦截对静态、非虚拟或私有成员的所有调用。您可以使用.NET Profiler API 来实现这一点。例如，TypeMock Isolator 使用它来监视应用程序的执行，当方法被调用时，CLR 会通知 typemock 隔离器，它允许 Isolator 完全覆盖原始类。

Answer 8

.NET 6.0 向 Reflection 命名空间添加了一个新候选对象：DispatchProxy。该团队正在宣布它here。文章中包含一个示例用法。