使用动态代理，提高工作效率

    动态代理的一个最主要的应用场合就是实现AOP － 截获方法调用，加入自己的预处理、后处理或Around处理。
    我在ESBasic.Emit中实现了对这些截获的支持。
    首先，介绍两个截获者：

    /// <summary>
    /// IMethodInterceptor 对方法进行截获并加入预处理和后处理。
    /// </summary>
    public interface IMethodInterceptor
    {
        void PreProcess(InterceptedMethod method);

        void PostProcess(InterceptedMethod method ,object returnVal);
    }

    IMethodInterceptor 很容易理解，用于为截获插入预处理、后处理。这个非常容易理解。

     /// <summary>
    /// IAroundInterceptor 对方法进行Around截获处理。注意，必须要触发目标方法的调用。
    /// </summary>
    public interface IAroundInterceptor
    {
        object AroundCall(InterceptedMethod method);
    }

    Around处理由IAroundInterceptor完成。什么是Around处理了？比如，我们想捕获目标方法的异常，需要使用TryCatch将目标方法Around起来，这就是Around处理的一个例子。
    在上面的接口方法中都有一个参数InterceptedMethod，它封装了被截获的目标方法的基本信息。

public sealed class InterceptedMethod
    {
        #region Ctor
        public InterceptedMethod() { }
        public InterceptedMethod(object _target, MethodInfo _method, object[] paras)
        {
            this.target = _target;
            this.method = _method;
            this.arguments = paras;
        } 
        #endregion

        #region Method
        private MethodInfo method;
        /// <summary>
        /// Method 被截获的目标方法
        /// </summary>
        public MethodInfo Method
        {
            get { return method; }
            set { method = value; }
        }
        #endregion

        #region Target
        private object target;
        /// <summary>
        /// Target 被截获的方法需要在哪个对象上调用。
        /// </summary>
        public object Target
        {
            get { return target; }
            set { target = value; }
        } 
        #endregion

        #region Arguments
        private object[] arguments;
        /// <summary>
        /// Arguments 调用被截获的方法的参数
        /// </summary>
        public object[] Arguments
        {
            get { return arguments; }
            set { arguments = value; }
        } 
        #endregion       

        #region Invoke
        /// <summary>
        /// Invoke 执行目标方法
        /// </summary>        
        public object Invoke()
        {
            return this.method.Invoke(this.target, this.arguments);
        } 
        #endregion
    }

    好，如何使用ESBasic.Emit来创建动态代理了？很简单，你只需要调用

public static TInterface CreateAopProxy<TInterface>(object origin, IMethodInterceptor methodInterceptor, IAroundInterceptor aroundInterceptor)

    如果不需要某种截获处理，对应的参数传入null即可。
    举个例子，我们需要使用动态代理截获IComputer所有方法调用抛出的异常，并记录日志。IComputer定义如下：

    public interface IComputer 
    {
        int Add(int a, int b);      
    }

    public class Computer : IComputer
    {
        public int Add(int a, int b)
        {
            throw new Exception("TestException");
            return a + b;
        }   
    } 

    我可以使用Around截获者来截获异常，所以我实现一个自己的IAroundInterceptor：

    public class ExceprionAroundInterceptor : IAroundInterceptor
    {
        #region IAroundInterceptor 成员
        public object AroundCall(InterceptedMethod method)
        {
            try
            {
                return method.Invoke();
            }
            catch (Exception ee)
            {
                ee = ee;
                //.. log Exception

                throw;
            }
        }
        #endregion
    }

    现在，我们可以这样获得针对IComputer的动态代理的引用：

    IComputer proxy = ESBasic.Emit.Application.DynamicProxyFactory.CreateAopProxy<IComputer>(new Computer() ,null ,new ExceprionAroundInterceptor()) ;
    proxy.Add(1, 2);

    这样就ok了，Add方法抛出的异常会被ExceprionAroundInterceptor截获。

    最后，提醒一下，如果你让Computer不从IComputer继承，运行结果也一样。你应该已经看到DynamicProxyFactory.CreateAopProxy方法的第一个参数是object类型，而不是泛型T，这说明只要对应的object包含了和目标接口一样的方法（签名完全一致）就可以 －－ 这就是所谓的“换脸”能力，可以在这里看到更详细的说明。
    由于动态代理是使用Emit发射实现，所以效率上来说，和你手写的代码是没有区别的。

    下载 ESBasic.Emit.dll。