.NET中通过代理实现面向方面编程(AOP)

/// <summary>  
    /// Aspect代理，在这个类里面，实现对方法的拦截  
    /// </summary>  
    public class AspectProxyErrorLog : RealProxy      
    {  
        AspectManagedAttribute attr;  
        /// <summary>  
        /// 默认构造函数  
        /// </summary>  
        public AspectProxyErrorLog() : base()  
        {  
        }  
        /// <summary>  
        /// 构造函数  
        /// </summary>  
        /// <param name="myType">被代理的类的类型</param>  
        public AspectProxyErrorLog(Type myType) : base(myType)  
        {  
        }  
        /// <summary>  
        /// 构造函数  
        /// </summary>  
        /// <param name="myType">被代理的类的类型</param>  
        /// <param name="obj">被代理的对象</param>  
        public AspectProxyErrorLog(Type myType,MarshalByRefObject obj) : base(myType)  
        {  
            target=obj;  
        }  
        MarshalByRefObject target;  
        ILog LogManage;  
        /// <summary>  
        /// 当在派生类中重写时，在当前实例所表示的远程对象上调用在所提供的 IMessage 中指定的方法。<br />  
        /// WebsharpAspect在这里执行对方法执行的拦截处理  
        /// </summary>  
        /// <param name="msg">IMessage，包含有关方法调用的信息。</param>  
        /// <returns>调用的方法所返回的消息，包含返回值和所有 out 或 ref 参数。</returns>  
        public override IMessage Invoke(IMessage msg)  
        {  
            IMessage retMsg=null ;  
            IMethodCallMessage methodCall = (IMethodCallMessage)msg;  
            IMethodReturnMessage methodReturn = null;  
 object[] copiedArgs = Array.CreateInstance(typeof(object), methodCall.Args.Length) as object[];  
            methodCall.Args.CopyTo(copiedArgs, 0);  
            object[] attrs = null;  
            CoustomerErrorHandleAttribute ceha = null;  
            if (msg is IConstructionCallMessage)  
            {  
 
                IConstructionCallMessage ccm = (IConstructionCallMessage)msg;  
                RemotingServices.GetRealProxy(target).InitializeServerObject(ccm);  
                ObjRef oRef = RemotingServices.Marshal(target);  
                RemotingServices.Unmarshal(oRef);  
retMsg = EnterpriseServicesHelper.CreateConstructionReturnMessage(ccm, (MarshalByRefObject)this.GetTransparentProxy());  
 
            }  
            else 
            {  
                IMethodCallMessage mcm = (IMethodCallMessage)msg;                  
                attrs = methodCall.MethodBase.GetCustomAttributes(typeof(CoustomerErrorHandleAttribute), false);                 
                ceha = LogManagerFactory.GetCoustomerErrorHandleAttribute(attrs, methodCall.MethodBase.Name );  
                if (null != ceha)  
                {  
                    LogManage = ceha.ILogName;  
                }  
                try 
                {  
                    object returnValue = methodCall.MethodBase.Invoke(this.target, copiedArgs);  
methodReturn = new ReturnMessage(returnValue, copiedArgs, copiedArgs.Length, methodCall.LogicalCallContext, methodCall);  
                      
                }  
                catch (Exception ex)  
                {  
                    if (null != ex.InnerException)  
                    {  
                        methodReturn = new ReturnMessage(ex.InnerException, methodCall);  
                    }  
                    else 
                    {  
                        methodReturn = new ReturnMessage(ex, methodCall);  
                    }  
                }  
                retMsg = methodReturn;  
 
            }  
            if (null != methodReturn)  
            {  
                if (null != methodReturn.Exception )  
                {  
                    if (null != this.LogManage )  
                    {  
this.LogManage.Error(ceha .MethodErrorText  + methodReturn.Exception.ToString());  
                    }  
 
                }  
            }  
            return retMsg;  
 
        }  
    } 

延伸阅读

面向切面编程：Aspect Oriented Programming

AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。

主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

原文标题：.net中利用代理实现AOP

链接：http://www.cnblogs.com/ASPNET2008/archive/2010/04/25/1720820.html