C# 实现 Aop [继承ContextBoundObject方式]

 [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    public class AopAttribute : ProxyAttribute
    {
       private IAopProxyBuilder builder=null;
       public AopAttribute(Type builderType)
       {
           this.builder = (IAopProxyBuilder)Activator.CreateInstance(builderType);
       }

        public override MarshalByRefObject CreateInstance(Type serverType)
        {
            AopProxy realProxy = new AopProxy(serverType);
            return realProxy.GetTransparentProxy() as MarshalByRefObject;
        }


    }

  [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    public class MethodAopAdviceAttribute : Attribute
    {

        private AdviceType type=AdviceType.None;
        public MethodAopAdviceAttribute(AdviceType advicetype)
        {
            this.type = advicetype;
        }

        public AdviceType AdviceType
        {
            get
            {
                return this.type;
            }
        }
    }

    public enum AdviceType
    {
        None,
        Before,
        After,
        Around
    }

  partial interface IAopAction
    {
        void PreProcess(IMessage requestMsg);
        void PostProcess(IMessage requestMsg, IMessage Respond);
    }
    public class AopProxy : RealProxy, IAopAction
    {
        public AopProxy(Type serverType)
            : base(serverType)
        {
        }
        public virtual void PreProcess(object obj,string method="",int argCount=0,object[] args=null)
        {
            var o=obj as AopClass;
            if (o!=null)
            {
                o.IsLock=false;
                o.Name="999999";
            }
        }

        public virtual void PreProcess(IMessage requestMsg)
        {  
            var o=GetUnwrappedServer();
            IMethodCallMessage call = requestMsg as IMethodCallMessage;
            if (call!=null)
            {
                this.PreProcess(o, call.MethodName, call.InArgCount, call.Args);
            }
            else
            {
                this.PreProcess(o);
            }
                  
        }

        public virtual void PostProcess(object obj, object returnValue=null,string method="", int argCount=0, object[] args=null)
        {
            var o=obj as AopClass;
            if (o!=null)
            {
                o.IsLock=true;
                o.Name="10101010";
            }
          

        }
        public virtual void PostProcess(IMessage requestMsg, IMessage Respond)
        {
              var o=GetUnwrappedServer();         
                ReturnMessage mm=Respond as ReturnMessage;
                var ret=mm.ReturnValue;
                IMethodCallMessage call = requestMsg as IMethodCallMessage;
                if (call!=null)
                {
                    this.PostProcess(o,ret,call.MethodName, call.InArgCount, call.Args);
                }
                else
                {
                    this.PostProcess(o, ret);
                }
        }

        //public virtual IMessage Proessed(IMessage msg,MarshalByRefObject target)
        //{
        //    IMethodCallMessage call = (IMethodCallMessage)msg;
        //    IConstructionCallMessage ctor = call as IConstructionCallMessage;
        //    if (ctor != null)
        //    {
        //        //获取最底层的默认真实代理  
        //        RealProxy default_proxy = System.Runtime.Remoting.RemotingServices.GetRealProxy(target);

        //        default_proxy.InitializeServerObject(ctor);
        //        MarshalByRefObject tp = (MarshalByRefObject)this.GetTransparentProxy();
        //        //自定义的透明代理 this  

        //        return System.Runtime.Remoting.Services.EnterpriseServicesHelper.CreateConstructionReturnMessage(ctor, tp);
        //    }

        //    IMethodReturnMessage result_msg =  System.Runtime.Remoting.RemotingServices.ExecuteMessage(target, call);
        //    //将消息转化为堆栈，并执行目标方法，方法完成后，再将堆栈转化为消息  
        //    return result_msg;
        //}

        public virtual IMessage Proessed(IMessage msg)
        {
            IMessage message;
            if (msg is IConstructionCallMessage)
            {
                message=this.ProcessConstruct(msg);
            }
            else
            {
                message=this.ProcessInvoke(msg);
            }
            return message;
        }
        public virtual void ChangeReturnValue(IMessage msg,ref object o)
        {
            if (msg is IMethodCallMessage)
            {
                var m=msg as IMethodCallMessage;
                string name= m.MethodName;
                if(name=="Hello")
                  o="Hello,Lucy!";
            }
        }
        public virtual IMessage ProcessInvoke(IMessage msg)
        {
            IMethodCallMessage callMsg = msg as IMethodCallMessage;
            IMessage message;
            try
            {   
                object[] args = callMsg.Args;   //方法参数                 
                object o = callMsg.MethodBase.Invoke(GetUnwrappedServer(), args);  //调用 原型类的 方法       
                ChangeReturnValue(msg,ref o);
                message = new ReturnMessage(o, args, args.Length, callMsg.LogicalCallContext, callMsg);   // 返回类型 Message
            }
            catch (Exception e)
            {
                message = new ReturnMessage(e, callMsg);
            }

            //Console.WriteLine("Call Method:"+callMsg.MethodName);
            //Console.WriteLine("Return:"+ message.Properties["__Return"].ToString());
            return message;
        }
        public virtual IMessage ProcessConstruct(IMessage msg)
        {
            IConstructionCallMessage constructCallMsg = msg as IConstructionCallMessage;
            //构造函数 初始化
            IConstructionReturnMessage constructionReturnMessage = this.InitializeServerObject((IConstructionCallMessage)msg);
            RealProxy.SetStubData(this, constructionReturnMessage.ReturnValue);

            //Console.WriteLine("Call constructor:"+constructCallMsg.MethodName);
            //Console.WriteLine("Call constructor arg count:"+constructCallMsg.ArgCount);

            return constructionReturnMessage;
        }

        public override IMessage Invoke(IMessage msg)
        {
           
           
            #region  获取AdviceType
            AdviceType type=AdviceType.None;
            IMethodCallMessage call = (IMethodCallMessage)msg;           
            foreach (Attribute attr in call.MethodBase.GetCustomAttributes(false))
            {
                MethodAopAdviceAttribute mehodAopAttr = attr as MethodAopAdviceAttribute;
                if (mehodAopAttr != null)
                {
                    type=mehodAopAttr.AdviceType;
                    break;
                }
            }
            #endregion
            IMessage message;         
            
           
            if (type==AdviceType.Before || type==AdviceType.Around)
            {
                this.PreProcess(msg); 
                Console.WriteLine("::Before Or Around");
            }
            message=this.Proessed(msg);
            if (type==AdviceType.After || type==AdviceType.Around)
            {
                this.PostProcess(msg, message);
                Console.WriteLine("::After Or Around");
            }

            return message;
        }
    }

 public interface IAopProxyBuilder
    {
        AopProxy CreateAopProxyInstance(Type type);
    }

    public class AopProxyBuilder : IAopProxyBuilder
    {        
        public AopProxy CreateAopProxyInstance(Type type)
        {
            return new AopProxy(type);
        }
    }

  [AopAttribute(typeof(AopProxyBuilder))]
    public class AopClass : ContextBoundObject
    {
     
        public string Name
        {
            get;
            set;
        }
        public bool IsLock=true;
        public AopClass(string name)
        {
            Name=name;
            Console.WriteLine("Aop Class Create Name:"+Name);
        }

        public AopClass()
        {
            Console.WriteLine("Aop Class Create");
        }

        

        [MethodAopAdvice(AdviceType.Around)]
        public string Hello()
        {
            Console.WriteLine("hello world:");
            return "hello world:";
        }

        [MethodAopAdvice(AdviceType.Before)]
        public string Say(string content)
        {  
            string c= "IsLock:"+IsLock+"\t "+Name+" :"+content;
            Console.WriteLine(c);
            return c;
        }
        public override string ToString()
        {
            return string.Format("Name:{0},IsLock:{1}", this.Name, this.IsLock);

        }
    }

   static void Test()
        {
            Console.WriteLine();
            AopClass ap=new AopClass("XiaoQiang");         
             Console.WriteLine("Show:"+ ap.Hello());
            Console.WriteLine(ap.ToString());
            Console.WriteLine();

            Console.WriteLine("Show:"+ ap.Say("hello,everybody!"));
            Console.WriteLine(ap.ToString());
            Console.WriteLine(ap.ToString());
        }

 【继承object 与继承ContextBoundObject 的性能差】

 public class ClsA
    {

        public void ToDo()
        {

        }

    }

    public class ClsB : ContextBoundObject
    {

        public void ToDo()
        {

        }

    }

 static void Main(string[] args)
        {         
            WatchToDo(ToDoA);
            WatchToDo(ToDoB);
            Console.ReadKey();
        }

       static  void ToDoA()
        {
            ClsA cl1 = new ClsA();
            cl1.ToDo();
        }
       static void ToDoB()
        {
            ClsB cl2 = new ClsB();
            cl2.ToDo();
        }
        static long WatchToDo(Action act)
        {
            System.Diagnostics.Stopwatch stop = new System.Diagnostics.Stopwatch();
            stop.Reset();
            stop.Start();
            for (int i=0; i<10000; i++)
                act();
            stop.Stop();
            Console.WriteLine("Time: "+stop.ElapsedTicks);
            return stop.ElapsedTicks;
        }

 测试结果：性能时间后者是前者的392倍.