上篇我們學(xué)習(xí)了的基本概念，我們回顧一下上篇提到的Advice(通知):所謂通知是指攔截到joinpoint(連接點)之后所要做的事情就是通知.通知分為前置通知，后置通知，異常通知，環(huán)繞通知。

　　的通知既可由某個類的所有對象共享，也可由該類型的單個實例獨占。共享的通知稱為基于類型（per-class）的通知，而獨占的通知稱為基于實例（per-instance）的通知。

基于類型的通知最為常用。很多常用功能很適合用基于類型的通知實現(xiàn)，比如說事務(wù)。它們不依賴于目標對象的狀態(tài)，也不會向目標對象添加新狀態(tài)，僅僅對方法及其參數(shù)進行操作。

　　基于實例的通知比較適合做引入(introductions)。此時通知可以向目標對象添加狀態(tài)。在代理中，可以同時使用基于類型和基于實例的通知。和spring框架略有不同，只有四種通知類型，沒有spring框架的最終通知(目前我還沒有實現(xiàn)最終通知，如果有朋友實現(xiàn)的話，可以給我留言)。
　　

　　一、攔截環(huán)繞通知(around advice)：中最基本的通知類型是攔截環(huán)繞通知（interception around advice），即方法攔截器。攔截環(huán)繞通知繼承IMethodInterceptor接口。注意其中IMethodInvocation.Proceed()方法的調(diào)用。該方法會依次調(diào)用攔截器鏈上的其它攔截器。大部分攔截器都需要調(diào)用這個方法并返回它的返回值。當然，也可以不調(diào)用Proceed方法，而返回一個其它值或拋出一個異常，但一般不太會這么做。

　　二、前置通知(before advise)：是在IMethodInterceptor.Proceed()方法調(diào)用前的通知。繼承自IMethodBeforeAdvice接口。

　　三、異常通知(throws advise)：是在IMethodInterceptor.Proceed()方法調(diào)用時發(fā)生異常的通知。繼承自IthrowsAdvice接口。IthrowsAdvice接口沒有定義任何方法：它是一個標識接口（按：之所以用標識接口，原因有二：1、在通知方法中，只有最后一個參數(shù)是必須的。如果聲明為接口的方法，參數(shù)列表就被固定了。2、如果第一個原因可以用重載的接口方法解決，那么這個原因就是使用標識接口的充分原因了：實現(xiàn)此接口的類必須聲明一或多個通知方法，接口方法做不到這一點），用以表明實現(xiàn)它的類聲明了一或多個強類型的異常通知方法。

　　四、后置通知(after returning advise)：是在IMethodInterceptor.Proceed()方法調(diào)用后的通知。繼承自IAfterReturningAdvice接口。后置通知對切入點的執(zhí)行沒有影響，如果通知拋出異常，就會沿攔截器鏈向上拋出，從而中斷攔截器鏈的繼續(xù)執(zhí)行。

　　代碼實現(xiàn)：

　　準備條件

　　四種通知：

AroundAdvise
    /**//// <summary>
    /// 環(huán)繞通知
    /// </summary>
    public class AroundAdvise : IMethodInterceptor
    {
        public object Invoke(IMethodInvocation invocation)
        {
  &nbsp;         Console.Out.WriteLine(string.Format(" 環(huán)繞通知： 調(diào)用的方法 '{0}'", invocation.Method.Name));
            Console.WriteLine();

            object returnValue = null;

  &nbsp;         try 
         &nbsp;  {
         &nbsp;      returnValue = invocation.Proceed();
   &nbsp;        }
      &nbsp;     catch
         ;   {
              ;  Console.Out.WriteLine(" 環(huán)繞通知： 發(fā)生異常");
                Console.WriteLine();
           ; }

        &nbsp;   Console.Out.WriteLine(String.Format(" 環(huán)繞通知： 返回值 '{0}'", returnValue));

        &nbsp;   return returnValue;
        }
    }

BeforeAdvise
    /**//// <summary>
    /// 前置通知
    /// </summary>
    public class BeforeAdvise : IMethodBeforeAdvice
    {
        public void Before(MethodInfo method, object[] args, object target)
        {
            Console.Out.WriteLine("  &nbsp;  前置通知： 調(diào)用的方法名 : " + method.Name);
        &nbsp;&nbsp;  Console.Out.WriteLine("  &nbsp;  前置通知： 目標       :&nbsp;" + target);
            Console.Out.WriteLine("     前置通知： 參數(shù)為&nbsp;  : ");
    &nbsp;&nbsp;      if (args != null)
     ;     &nbsp; {
           &nbsp;    foreach (object arg in args)
     ;       &nbsp;   {
   &nbsp;                Console.Out.WriteLine("\t: " + arg);
     &nbsp;          }
           &nbsp;}

            Console.WriteLine();
        }
    }

ThrowsAdvise
    /**//// <summary>
    /// 異常通知
    /// </summary>
    public class ThrowsAdvise : IThrowsAdvice 
    {
        public void AfterThrowing(Exception ex)
        {
    ;        string errorMsg = string.Format("     ;異常通知： 方法拋出的異常 : {0}", ex.Message);
            Console.Error.WriteLine(errorMsg);

            Console.WriteLine();
        }
    }

AfterReturningAdvise
    /**//// <summary>
    /// 后置通知
    /// </summary>
    public class AfterReturningAdvise : IAfterReturningAdvice
    {
        public void AfterReturning(object returnValue, MethodInfo method, object[] args, object target)
        {
&nbsp;           Console.Out.WriteLine("  &nbsp;  后置通知： 方法調(diào)用成功，方法名 : " + method.Name);
   &nbsp;        Console.Out.WriteLine("     后置通知： 目標為      : " + target);
        ;    Console.Out.WriteLine("   &nbsp; 后置通知： 參數(shù) ;: ");
      &nbsp;     if (args != null)
       &nbsp;    {
          &nbsp; &nbsp;   foreach (object arg in args)
    &nbsp;           {
                  &nbsp; Console.Out.WriteLine("\t: " + arg);
      &nbsp;         }
&nbsp;   &nbsp;       }
      &nbsp;     Console.Out.WriteLine("     后置通知：  返回值是&nbsp;: " + returnValue);

            Console.WriteLine();
        }
    }

 　　接口：

    public interface IOrderService
    {
        object Save(object id);
    }

　　一、沒有異常的情況

OrderService
    public class OrderService : IOrderService
    {
        /**//// <summary>
        /// 攔截該方法
        /// </summary>
        /// <param&nbsp;name="id"></param>
        /// <returns></returns>
        public object Save(object id)
        {
       &nbsp;   &nbsp;//throw new Exception("由于XXX原因保存出錯&quot;); &nbsp;
            return "保存：" + id.ToString();
        }
    }

Program
    class Program
    {
        static void Main(string[] args)
        {
      &nbsp;     ProxyFactory factory = new ProxyFactory(new OrderService());

     ;       factory.AddAdvice(new AroundAdvise());
      &nbsp;     factory.AddAdvice(new BeforeAdvise());
            factory.AddAdvice(new AfterReturningAdvise());
           &nbsp;factory.AddAdvice(new ThrowsAdvise());

            IOrderService service = (IOrderService)factory.GetProxy();

      &nbsp;     object result = service.Save(1);

            Console.WriteLine();
           &nbsp;Console.WriteLine(string.Format("客戶端返回值：{0}", result));
            
            Console.ReadLine();
        }
    }

　　輸出效果：見圖1

圖1

　　二、有異常的情況：

OrderService
public class OrderService : IOrderService
    {
        /**//// <summary>
        /// 攔截該方法
        /// </summary>
        /// <param name=&quot;id"></param>
        /// <returns></returns>
        public object Save(object id)
        {
        &nbsp;   throw new Exception("由于XXX原因保存出錯");  
        &nbsp;   //return "保存：&quot; + id.ToString();
        }
    }

　　輸出效果：見圖2

圖2

　　從圖與代碼中，我們不難看出Advice(通知)的生命周期。攔截環(huán)繞通知(around advice)圍繞著整個攔截過程；前置通知(before advise)在方法調(diào)用前執(zhí)行；異常通知(throws advise)在調(diào)用方法時發(fā)生異常才執(zhí)行，否則不執(zhí)行；后置通知(after returning advise)在方法調(diào)用后執(zhí)行，當調(diào)用時出現(xiàn)異常，則不執(zhí)行后置通知(after returning advise)。