Castle动态代理技术初探

一、需求的提出

    假设朋友给我一个CalculatorLib.dll文件，里面包含了一个计算器接口和一个实现了该接口的计算器类，我的程序里要用到这个计算器来计算两个整数的和(仅作为简单例子，不考虑溢出处理等其他方面)，计算器的实现大概如下：

    public interface ICalculator
    {
        Int32 AddOperation(Int32 p1, Int32 p2);
    }

    public class Calculator : ICalculator
    {
        public virtual Int32 AddOperation(Int32 p1, Int32 p2)
        {
            //①

            //②

            return p1 + p2;
            //③

        }
    }

    我的需求是：想在①这里为代码赋予修改输入参数和返回值的权限，在②更改参数和返回值，在③这里收回该权限，分两种情况：

     1、我手里有源代码

     我会去直接改AddOperation方法，引入权限控制的程序集，在①和③处加入权限控制代码，在②处加入修改输入参数的代码，也许还要重新写一下return后边的东西，基本上这样做就能够满足要求；

    2、我手里只有这个dll没有源代码

     这时候我的主程序要引入权限控制的程序集，然后写一个方法，让这个方法在调用AddOperation之前做权限赋予和参数修改，在调用AddOperation之后做权限收回。

     看看缺点：都需要引入权限控制的程序集后将权限控制和纯计算逻辑放在一起，不满足单一职责原则；扩展性也不太好；如果计算器类中还有减、乘除等很多方法，而每个方法都需要有权限的赋予和收回，这就意味着会有大量重复代码：赋予权限和收回权限。

怎么办呢？其实我们可以利用代理模式把计算器类改造一下，当然前提是AddOperation必须为虚函数，如下：

    public class CalculatorProxy : Calculator
    {
        public override Int32 AddOperation(Int32 p1, Int32 p2)
        {
            Int32 pa1 = p1;
            Int32 pa2 = p2;
            this.GrantPermission();
            this.ModifyParams(ref pa1, ref pa2);
            return this.ModifyReturnValue(this.InvokeMethod(pa1, pa2));
        }

        private Int32 InvokeMethod(Int32 p1, Int32 p2)
        {
            return  base.AddOperation(p1, p2);
        }

        private void GrantPermission() { }

        private void RevokePermission() { }

        private void ModifyParams(ref Int32 p1, ref Int32 p2)
        {
            p1 = 2;
            p2 = 1;
        }

        private Int32 ModifyReturnValue(Int32 value)
        {
            return value + 1;
        }
    }

 

   

     这么写似乎好点，对权限程序集的依赖被转移到了代理类当中，如果所有算术计算方法都需要订制自己的权限控制策略，那么我们就要为它们增加各自的GrantPermission和RevokePermission方法，代码似乎不太优雅而且最好能在我们需要的时候执行权限控制，让我们的精力放在核心业务逻辑上；最后，上面的代理类处理方式有一个固定的模式，调用方法前准备活动——>调用目标方法——>调用结束后处理活动，让我们想到策略模式。

二、一种解决方案

     要较好的实现上面的需求，可以使用动态代理技术。在动态代理方面我觉得开源项目Castle做的挺好，朴实无华，在它动态生成的类中甚至连像委托(delegate)这样稍复杂的东西都没用到。

    下面以Castle的动态代理框架：DynamicProxy做为工具，涉及到的dll有：Castle.Core.dll和Castle.DynamicProxy2.dll。

先给出例子的源码：

    class Program
    {
        static void Main(string[] args)
        {
            String path = AppDomain.CurrentDomain.BaseDirectory;
            ModuleScope scope = new ModuleScope(true, "Invocation", path + "\\Invocation.dll", "Proxy", path + "\\Proxy.dll");
            DefaultProxyBuilder builder = new DefaultProxyBuilder(scope);
            ProxyGenerator pg = new ProxyGenerator(builder);
            ICalculator cal = pg.CreateClassProxy(typeof(Calculator), new PermissionInterceptor(), new ModifyInterceptor()) 

                              as ICalculator;

                        

                   Console.WriteLine("待计算表达式为：+ 3 = ?,方法最初传入参数为:(1,1)\n");

                   Console.WriteLine("表达式:1 + 3 = {0}\n",cal.AddOperation(1,1));

                   scope.SaveAssembly(true); //加这句话可以将动态生成的Invocation类保存到本地硬盘

                   scope.SaveAssembly(false); //加这句话可以将动态生成的Proxy类保存到本地硬盘

             Console.ReadKey();
        }
    }

    public class PermissionInterceptor : StandardInterceptor
    {
        protected override void PreProceed(IInvocation invocation)
        {
            Console.WriteLine("申请更改参数和返回值的权限....\n");
        }

        protected override void PostProceed(IInvocation invocation)
        {
            Console.WriteLine("收回更改参数和返回值的权限....\n");
        }
    }

    public class ModifyInterceptor : StandardInterceptor
    {
        protected override void PreProceed(IInvocation invocation)
        {
            Console.WriteLine("----------------------Begin----------------------------\n");
            Console.WriteLine("对参数值进行拦截\n");
            invocation.SetArgumentValue(0, 2);
            invocation.SetArgumentValue(1, 1);
            Console.WriteLine("方法参数为:(2,1)\n");
            Console.WriteLine("----------------------End----------------------------\n");
        }

        protected override void PostProceed(IInvocation invocation)
        {
            Console.WriteLine("----------------------Begin----------------------------\n");
            Console.WriteLine("对返回值进行拦截并加1\n");
            invocation.ReturnValue = Int32.Parse(invocation.ReturnValue.ToString()) + 1;
            Console.WriteLine("----------------------End----------------------------\n");
        }
    }

    其中的PermissionInterceptor和ModifyInterceptor为自定义拦截器，前者用作权限控制，后者用作参数和返回值更改。

     1、熟悉一下IInvocation接口，我更愿意把实现了该接口的类型叫做一个上下文环境，其中包含的被代理方法的参数、元数据、返回值、返回类型等信息，类似于这样：

   public interface IInvocation
    {
        object GetArgumentValue(int index);
        MethodInfo GetConcreteMethod();
        MethodInfo GetConcreteMethodInvocationTarget();
        void Proceed();
        void SetArgumentValue(int index, object value);

        object[] Arguments { get; }
        Type[] GenericArguments { get; }
        object InvocationTarget { get; }
        MethodInfo Method { get; }
        MethodInfo MethodInvocationTarget { get; }
        object Proxy { get; }
        object ReturnValue { get; set; }
        Type TargetType { get; }
    }

     2、是拦截器接口：IInterceptor和一个标准拦截器：StandardInterceptor；IInterceptor里面就一个方法：

   void Intercept(IInvocation invocation)

     StandardInterceptor如下，一个典型的策略模式，由于拦截器继承了MarshalByRefObject，所以它的实例不会离开创建它的AppDomain，其他AppDomain中的实例

会以remoting的方式使用它，另外拦截器需要的参数只有IInvocation，一般来说我们要通过继承标准拦截器来自定义拦截器。

    public class StandardInterceptor : MarshalByRefObject, IInterceptor
    {
        public void Intercept(IInvocation invocation)
        {
            this.PreProceed(invocation);
            this.PerformProceed(invocation);
            this.PostProceed(invocation);
        }

        protected virtual void PerformProceed(IInvocation invocation)
        {
            invocation.Proceed();
        }

        protected virtual void PostProceed(IInvocation invocation)
        {
        }

        protected virtual void PreProceed(IInvocation invocation)
        {
        }
    }

    3、Castle为我们动态生成的类型有：代理类、实现了IInvocation接口的上下文环境，一下代码为Reflector反编译结果，像methodof理解为从元数据表中获取指定类型的指定方法的元数据信息(注：使用Castle官网提供的“Release Candidate 3 - September 20, 2007”下的SourceCode生成的Proxy类和Invocation类与“Monorail 2 - January 17th, 2010”下的release版本生成的类有所不同，如，前者生成的Invocation类是作为Proxy类的内嵌类实现的，以下生成代码使用的是后者)：

    ① CalculatorProxy类：

    [Serializable, XmlInclude(typeof(Calculator))]
    public class CalculatorProxy : Calculator, IProxyTargetAccessor
    {
        [XmlIgnore]
        public IInterceptor[] __interceptors;
        public static ProxyGenerationOptions proxyGenerationOptions;
        public static MethodInfo token_AddOperation = ((MethodInfo)methodof(Calculator.AddOperation, Calculator));

        public CalculatorProxy()
        {
            this.__interceptors = new IInterceptor[] { new StandardInterceptor() };
        }

        public CalculatorProxy(IInterceptor[] interceptorArray1)
        {
            this.__interceptors = interceptorArray1;
        }

        public override int AddOperation(int p1, int p2)
        {
            Calculator_AddOperation operation = new Calculator_AddOperation(typeof(Calculator), this, this.__interceptors, token_AddOperation, new object[] { p1, p2 });
            operation.Proceed();
            return (int)operation.ReturnValue;
        }

        public override int AddOperation_callback(int p1, int p2)
        {
            return base.AddOperation(p1, p2);
        }

        public override object DynProxyGetTarget()
        {
            return this;
        }

        public override IInterceptor[] GetInterceptors()
        {
            return this.__interceptors;
        }
    }

     ② Calculator_AddOperation类(Invocation)

    [Serializable]
    public class Calculator_AddOperation : InheritanceInvocation
    {
        // Methods
        public Calculator_AddOperation(Type type1, object obj1, IInterceptor[] interceptorArray1, MethodInfo info1, object[] objArray1)
            : base(type1, obj1, interceptorArray1, info1, objArray1)
        {
        }

        public override void InvokeMethodOnTarget()
        {
            int num = (base.proxyObject as CalculatorProxy).AddOperation_callback((int)base.GetArgumentValue(0), (int)base.GetArgumentValue(1));
            base.ReturnValue = num;
        }
    }

     Calculator_AddOperation类间接实现了一个抽象类AbstractInvocation，我们只看其中的Proceed方法：

    public void Proceed()
    {
        if (this.interceptors == null)
        {
            this.InvokeMethodOnTarget();
        }
        else
        {
            this.execIndex++;
            if (this.execIndex == this.interceptors.Length)
            {
                this.InvokeMethodOnTarget();
            }
            else
            {
                if (this.execIndex > this.interceptors.Length)
                {
                    string str;
                    if (this.interceptors.Length > 1)
                    {
                        str = " each one of " + this.interceptors.Length + " interceptors";
                    }
                    else
                    {
                        str = " interceptor";
                    }
                    throw new InvalidOperationException(string.Concat(new object[] { "This is a DynamicProxy2 error:”+ 

                    "invocation.Proceed() has been called more times than expected.This usually signifies a bug in the"+

                    "calling code. Make sure that", str, " selected for this method '", this.Method, "'calls invocation.Proceed() at most once." }));
                }
                this.interceptors[this.execIndex].Intercept(this);
            }
        }
    }

    其中execIndex便是当前正在使用的拦截器(interceptor)，通过this.interceptors[this.execIndex].Intercept(this);执行当前拦截器的PreProceed方法后触发下一个拦截器，这是一种嵌套的触发方式，实际工作流程如下图所示：

    实际上从上面代码也可以看出：CalculatorProxy类与Calculator_AddOperation类是互相知道的，所以用Reflector看，它们程序集之间是相互引用的，如图：

 

 

    通过Castle的动态代理框架可以很方便的进行AOP编程，需要注意的是被代理类里面需要被拦截的方法必须是虚方法，不同的虚方法可以共用相同的拦截器。

三、总结

    初学Castle动态代理技术，让我钦佩这些开源项目的作者，钦佩的同时意识到需要努力提高自己，学习依然在进行，希望能和园子里的朋友们一起分享。

 本文源代码