如何用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

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

Answer 2

我应该早点写这篇文章，但没关系。

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

有两种解决方案：

1. RealProxy 和朋友，基本上意味着使用 .NET Remoting。需要从 ContextBoundObject 继承。

   • 此方法利用了 .NET JIT 编译器提供的“魔力”
     （经过硬编码以专门识别RealProxy），让您“覆盖”非虚拟成员.

2. 使用 System.Reflection.Emit 构建代理 由 spring 你也可以看看他们的代码 ProxyFactoryObject。这里有另外三个关于 href="http://weblogs.asp.net/seanmcalinden/archive/2010/03/18/creating-a-dynamic-proxy-generator-part-1-creating-the- assembly-builder-module-builder-and -caching-mechanism.aspx" rel="nofollow noreferrer">主题。

   • 这种方法有一个严重的缺点，即限制您只能覆盖虚拟成员。

Answer 3

.NET 6.0 向 Reflection 命名空间添加了一个新的候选者：DispatchProxy。该团队在此处宣布这一消息。文章中包含示例用法。

Answer 4

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

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

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

Answer 5

另一个选项是 ContextBoundObject。

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

Answer 6

您可以仅使用 System.Danymic 命名空间中的 DynamicObject 来完成此操作，而无需使用任何第三方库。

示例代码：

public class DynamicProxy: DynamicObject
    {
        private readonly T _object;

        // The inner dictionary.
        Dictionary<string, object> dictionary = new Dictionary<string, object>();

        // Getting a property.
        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            return dictionary.TryGetValue(binder.Name, out result);
        }

        // Setting a property.
        // You can set up access control eg. if you don't want to 
        // set certain field, you can return false before putting
        // the value into the inner dictionary
        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            if (binder.Name.Equals("Rating")) return false;
            dictionary[binder.Name] = value;
            return true;
        }

        public DynamicProxy(T object)
        {
            _object = object;
            dictionary["Name"] = object.GetName();
            dictionary["Gender"] = object.GetGender();
            dictionary["Interests"] = object.GetInterests();
            dictionary["Rating"] = object.GetGeekRating();
        }

        public string GetName()
        {
            return (string)dictionary["Name"];
        }

        public int GetGeekRating()
        {
            return (int)dictionary["Rating"];
        }
}

然后在驱动程序类上：

dynamic dynamicProxy = new DynamicProxy(person);

这样，您可以设置和获取具有访问控制的字段。

Answer 7

要在类中的每个函数之前和之后添加任何功能，真实代理是一个很好的方法。

所以现在 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 8

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

Answer 9

您可以结合使用 DynamicObject 和 < a href="https://github.com/ekonbenefits/impromptu-interface" rel="noreferrer">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 ，然后放弃鸭子铸造。

我制作了该对象代理的透明可扩展版本，并在此处将其开源。