/// <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