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

void PostProcess(InterceptedMethod method ,object returnVal);
    }

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

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
    }

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

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

    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 proxy = ESBasic.Emit.Application.DynamicProxyFactory.CreateAopProxy<IComputer>(new Computer() ,null ,new ExceprionAroundInterceptor()) ;
    proxy.Add(1, 2);