使用AOP 使C#代碼更清晰 轉yanghua_kobe

標籤：

http://blog.csdn.net/yanghua_kobe/article/details/6917228

 

簡介如果你很熟悉面向方面編程(AOP)，你就會知道給代碼增加“切面”可以使代碼更清晰並且具有可維護性。但是AOP通常都依賴於第三方類庫或者硬式編碼.net特性來工作。雖然這些實現方式的好處大於它們的複雜程度，但是我仍然在尋找一種實現AOP的更為簡單的方式，來試My Code更為清晰。我將它們單獨移出來，並命名為AspectF。Aspect Oriented Programming (AOP)的背景“切面”指的是那些在你寫的代碼中在項目的不同部分且有相同共性的東西。它可能是你代碼中處理異常、記錄方法調用、時間處理、重新執行一些方法等等的一些特殊方式。如果你沒有使用任何面向切面編程的類庫來做這些事情，那麼在你的整個項目中將會遺留一些很簡單而又重複的代碼，它將使你的代碼很難維護。例如，在你的商務邏輯層有些方法需要被記錄，有些異常需要被處理，有些執行需要計時，資料庫操作需要重試等等。所以，也許你會寫出下面這樣的代碼。[csharp] view plaincopyprint?    public bool InsertCustomer(string firstName, string lastName, int age,           Dictionary<string, string> attributes)      {          if (string.IsNullOrEmpty(firstName))               throw new ApplicationException("first name cannot be empty");          if (string.IsNullOrEmpty(lastName))              throw new ApplicationException("last name cannot be empty");          if (age < 0)              throw new ApplicationException("Age must be non-zero");          if (null == attributes)              throw new ApplicationException("Attributes must not be null");                    // Log customer inserts and time the execution          Logger.Writer.WriteLine("Inserting customer data...");          DateTime start = DateTime.Now;                    try          {              CustomerData data = new CustomerData();              bool result = data.Insert(firstName, lastName, age, attributes);              if (result == true)              {                  Logger.Writer.Write("Successfully inserted customer data in "                       + (DateTime.Now-start).TotalSeconds + " seconds");              }              return result;          }          catch (Exception x)          {              // Try once more, may be it was a network blip or some temporary downtime              try              {                  CustomerData data = new CustomerData();                  if (result == true)                  {                      Logger.Writer.Write("Successfully inserted customer data in "                           + (DateTime.Now-start).TotalSeconds + " seconds");                  }                  return result;              }              catch               {                  // Failed on retry, safe to assume permanent failure.                  // Log the exceptions produced                  Exception current = x;                  int indent = 0;                  while (current != null)                  {                      string message = new string(Enumerable.Repeat(‘\t‘, indent).ToArray())                          + current.Message;                      Debug.WriteLine(message);                      Logger.Writer.WriteLine(message);                      current = current.InnerException;                      indent++;                  }                  Debug.WriteLine(x.StackTrace);                  Logger.Writer.WriteLine(x.StackTrace);                  return false;              }          }      }   你會看到上面只有兩行關鍵代碼，它調用了CustomerData執行個體的一個方法插入了一個Customer。但去實現這樣的商務邏輯，你真的很難去照顧所有的細節(日誌記錄、重試、異常處理、操作計時)。項目越成熟，在你的代碼中需要維護的這些“邊邊角角”就更多了。所以你肯定經常會到處拷貝這些“樣板”代碼，但只在這些樣板內寫少了真是的東西。這多不值！你不得不對每個商務邏輯層的方法都這麼做。比如現在你想在你的商務邏輯層中增加一個UpdateCustomer方法。你不得不再次拷貝所有的這些“樣板”，然後將兩行關鍵代碼加入其中。思考這樣的情境，你需要做出一個項目層級的改變——針對如何處理異常。你不得不處理你寫的這“上百”的方法，然後一個一個地修改它們。如果你想修改計時的邏輯，做法同樣如此。面向切面編程就可以很好地處理這些問題。當你採用AOP，你會以一種很酷的方式來實現它：[csharp] view plaincopyprint?    [EnsureNonNullParameters]      [Log]      [TimeExecution]      [RetryOnceOnFailure]      public void InsertCustomerTheCoolway(string firstName, string lastName, int age,          Dictionary<string, string> attributes)      {          CustomerData data = new CustomerData();          data.Insert(firstName, lastName, age, attributes);      }  這裡你需要區分這些通用的東西，像日誌記錄、計時、重試、驗證等這些通常被稱為“邊邊角角”的東西，最重要的是完全與你的“真實”代碼無關。這可以使方法將會變得美觀而清晰。所有的這些細節都在方法外被處理，並且只是在代碼外加上了一些屬性。這裡，每一個屬性代表一個Aspect(切面)。例如，你可以增加“日誌記錄”切面到任何代碼中，只需要增加一個Log屬性。無論你使用何種AOP的類庫，該類庫都能夠確保這些“切面”被有效地加入到代碼中，當然時機不一，可能是在編譯時間，也可能是在運行時。有許多AOP類庫通過使用編譯事件和IL操作允許你在編譯時間“處理”這些方面，例如PostSharp；而某些類庫使用DynamicProxy在運行時處理；某些要求你的類繼承自ContextBoundObject使用C#內建特性來supportAspects。所有的這些都有某些“不便”。你不得不使用某些外部庫，做足夠的效能測試來那些類庫可擴充等等。而你需要的只是一個非常簡單的方式來實現“隔離”，可能並不是想要完全實現AOP。記住，你的目的是隔離那些並不重要的核心代碼，來讓一切變得簡單並且清晰！AspectF如何來讓這一切變得簡單！讓我展示一種簡答的方式來實現這種隔離，僅僅使用標準的C#代碼，類和代理的簡單調用，沒有用到“特性”或者“IL操作”這些東西。它提供了可重用性和可維護性。最好的一點是它的“輕量級”——僅僅一個很小得類。[csharp] view plaincopyprint?    public void InsertCustomerTheEasyWay(string firstName, string lastName, int age,          Dictionary<string, string> attributes)      {          AspectF.Define              .Log(Logger.Writer, "Inserting customer the easy way")              .HowLong(Logger.Writer, "Starting customer insert",               "Inserted customer in {1} seconds")              .Retry()              .Do(() =>                  {                      CustomerData data = new CustomerData();                      data.Insert(firstName, lastName, age, attributes);                  });      }  讓我們看看它與通常的AOP類庫有何不同：(1)     不在方法的外面定義“切面”，而是在方法的內部直接定義。(2)     取代將“切面”做成類，而是將其構建成方法現在，看看它有什麼優勢：(1)     沒有很“深奧”的要求(Attributes, ContextBoundObject, Post build event, IL Manipulation,DynamicProxy)(2)     沒有對其他依賴的效能擔憂(3)     直接隨意組合你要的“切面”。例如，你可以只對日誌記錄一次，但嘗試很多次操作。(4)     你可以傳遞參數，局部變數等到“切面”中，而你在使用第三方類庫的時候，通常不能這麼做(5)     這不是一個完整的架構或類庫，而僅僅是一個叫做AspectF的類(6)     可能以在代碼的任何地方定義方面，例如你可以將一個for 迴圈包裹成一個“切面”讓我們看看使用這種方案構建一個“切面”有多簡單！這個方案中“切面”都是以方法來定義的。AspectExtensions類包含了所有的這些“預構建”的切面，比如：Log、Retry、TrapLog、TrapLogThrow等。例如，這裡展示一下Retry是如何工作的：[csharp] view plaincopyprint?    [DebuggerStepThrough]      public static AspectF Retry(this AspectF aspects)      {          return aspects.Combine((work) =>               Retry(1000, 1, (error) => DoNothing(error), DoNothing, work));      }            [DebuggerStepThrough]      public static void Retry(int retryDuration, int retryCount,           Action<Exception> errorHandler, Action retryFailed, Action work)      {          do          {              try              {                  work();              }              catch (Exception x)              {                  errorHandler(x);                  System.Threading.Thread.Sleep(retryDuration);              }          } while (retryCount-- > 0);          retryFailed();      }  你可以讓“切面”調用你的代碼任意多次。很容易在Retry切面中包裹對資料庫、檔案IO、網路IO、Web Service的調用，因為它們經常由於各種基礎設施問題而失敗，並且有時重試一次就可以解決問題。我有個習慣是總是去嘗試資料庫插入，更新，刪除、web service調用，處理檔案等等。而這樣的“切面”無疑讓我對處理這樣的問題時輕鬆了許多。下面展示了一下它是如何工作的，它建立了一個代理的組合。而結果就像如下這段代碼：[csharp] view plaincopyprint?    Log(() =>      {          HowLong(() =>          {              Retry(() =>              {                  Do(() =>                  {                      CustomerData data = new CustomerData();                      data.Insert(firstName, lastName, age, attributes);                  });              });          });      });  AspectF類除了壓縮這樣的代碼之外，其他什麼都沒有。下面展示，你怎樣建立你自己的“切面”。首先為AspectF類建立一個擴充方法。比如說，我們建立一個Log：[csharp] view plaincopyprint?    [DebuggerStepThrough]      public static AspectF Log(this AspectF aspect, TextWriter logWriter,                   string beforeMessage, string afterMessage)      {          return aspect.Combine((work) =>          {              logWriter.Write(DateTime.Now.ToUniversalTime().ToString());              logWriter.Write(‘\t‘);              logWriter.Write(beforeMessage);              logWriter.Write(Environment.NewLine);                    work();                    logWriter.Write(DateTime.Now.ToUniversalTime().ToString());              logWriter.Write(‘\t‘);              logWriter.Write(afterMessage);              logWriter.Write(Environment.NewLine);          });      }  你調用AspectF的Combine方法來壓縮一個將要被放進委託鏈的委託。委託鏈在最後將會被Do方法調用。[csharp] view plaincopyprint?    public class AspectF      {          /// <summary>          /// Chain of aspects to invoke          /// </summary>          public Action<Action> Chain = null;          /// <summary>          /// Create a composition of function e.g. f(g(x))          /// </summary>          /// <param name="newAspectDelegate">A delegate that offers an aspect‘s behavior.           /// It‘s added into the aspect chain</param>          /// <returns></returns>          [DebuggerStepThrough]          public AspectF Combine(Action<Action> newAspectDelegate)          {              if (this.Chain == null)              {                  this.Chain = newAspectDelegate;              }              else              {                  Action<Action> existingChain = this.Chain;                  Action<Action> callAnother = (work) =>                       existingChain(() => newAspectDelegate(work));                  this.Chain = callAnother;              }              return this;          }  這裡Combine方法操作的是被“切面”擴充方法傳遞過來的委託，例如Log，然後它將該委託壓入之前加入的一個“切面”的委託中，來保證第一個切面調用第二個，第二個調用第三個，知道最後一個調用真實的(你想要真正執行的)代碼。Do/Return方法做最後的執行操作。[csharp] view plaincopyprint?    /// <summary>      /// Execute your real code applying the aspects over it      /// </summary>      /// <param name="work">The actual code that needs to be run</param>      [DebuggerStepThrough]      public void Do(Action work)      {          if (this.Chain == null)          {              work();          }          else          {              this.Chain(work);          }      }  就是這些，現在你有一個非常簡單的方式來分隔那些你不想過度關注的代碼，並使用C#享受AOP風格的編程模式。AspectF類還有其他幾個方便的“切面”，大致如下（當然你完全可以DIY你自己的‘切面’）。[csharp] view plaincopyprint?    public static class AspectExtensions          {              [DebuggerStepThrough]              public static void DoNothing()              {                    }                    [DebuggerStepThrough]              public static void DoNothing(params object[] whatever)              {                    }                    [DebuggerStepThrough]              public static AspectF Delay(this AspectF aspect, int milliseconds)              {                  return aspect.Combine((work) =>                  {                      System.Threading.Thread.Sleep(milliseconds);                      work();                  });              }                    [DebuggerStepThrough]              public static AspectF MustBeNonNull(this AspectF aspect, params object[] args)              {                  return aspect.Combine((work) =>                  {                      for (int i = 0; i < args.Length; i++)                      {                          object arg = args[i];                          if (arg == null)                          {                              throw new ArgumentException(string.Format("Parameter at index {0} is null", i));                          }                      }                      work();                  });              }                    [DebuggerStepThrough]              public static AspectF MustBeNonDefault<T>(this AspectF aspect, params T[] args) where T : IComparable              {                  return aspect.Combine((work) =>                  {                      T defaultvalue = default(T);                      for (int i = 0; i < args.Length; i++)                      {                          T arg = args[i];                          if (arg == null || arg.Equals(defaultvalue))                          {                              throw new ArgumentException(string.Format("Parameter at index {0} is null", i));                          }                      }                      work();                  });              }                    [DebuggerStepThrough]              public static AspectF WhenTrue(this AspectF aspect, params Func<bool>[] conditions)              {                  return aspect.Combine((work) =>                  {                      foreach (Func<bool> condition in conditions)                      {                          if (!condition())                          {                              return;                          }                      }                      work();                  });              }                    [DebuggerStepThrough]              public static AspectF RunAsync(this AspectF aspect, Action completeCallback)              {                  return aspect.Combine((work) => work.BeginInvoke(asyncresult =>                  {                      work.EndInvoke(asyncresult); completeCallback();                  }, null));              }                    [DebuggerStepThrough]              public static AspectF RunAsync(this AspectF aspect)              {                  return aspect.Combine((work) => work.BeginInvoke(asyncresult =>                  {                      work.EndInvoke(asyncresult);                  }, null));              }          }  現在，你已經擁有了一個簡潔的方式來隔離那些細枝末節的代碼，去享受AOP形式的編程而無需使用任何“笨重”的架構。

 

使用AOP 使C#代碼更清晰 轉yanghua_kobe