隨筆 - 100  文章 - 50  trackbacks - 0
          <2013年8月>
          28293031123
          45678910
          11121314151617
          18192021222324
          25262728293031
          1234567

          常用鏈接

          留言簿(3)

          隨筆分類

          隨筆檔案

          文章分類

          文章檔案

          收藏夾

          我收藏的一些文章!

          搜索

          •  

          最新評論

          閱讀排行榜

          評論排行榜

          設計模式學習筆記-觀察者模式

          1. 概述

            有時被稱作發布/訂閱模式,觀察者模式定義了一種一對多的依賴關系,讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態發生變化時,會通知所有觀察者對象,使它們能夠自動更新自己。

          2. 解決的問題

            將一個系統分割成一個一些類相互協作的類有一個不好的副作用,那就是需要維護相關對象間的一致性。我們不希望為了維持一致性而使各類緊密耦合,這樣會給維護、擴展和重用都帶來不便。觀察者就是解決這類的耦合關系的。

          3. 模式中的角色

            3.1 抽象主題(Subject):它把所有觀察者對象的引用保存到一個聚集里,每個主題都可以有任何數量的觀察者。抽象主題提供一個接口,可以增加和刪除觀察者對象。

            3.2 具體主題(ConcreteSubject):將有關狀態存入具體觀察者對象;在具體主題內部狀態改變時,給所有登記過的觀察者發出通知。

            3.3 抽象觀察者(Observer):為所有的具體觀察者定義一個接口,在得到主題通知時更新自己。

            3.4 具體觀察者(ConcreteObserver):實現抽象觀察者角色所要求的更新接口,以便使本身的狀態與主題狀態協調。

          4. 模式解讀

            4.1 觀察者模式的類圖  

            

            4.2 觀察者模式的代碼

          復制代碼
              /// <summary>
              /// 抽象主題類
              /// </summary>
              public abstract class Subject
              {
                  private IList<Observer> observers = new List<Observer>();
          
                  /// <summary>
                  /// 增加觀察者
                  /// </summary>
                  /// <param name="observer"></param>
                  public void Attach(Observer observer)
                  {
                      observers.Add(observer);
                  }
          
                  /// <summary>
                  /// 移除觀察者
                  /// </summary>
                  /// <param name="observer"></param>
                  public void Detach(Observer observer)
                  {
                      observers.Remove(observer);
                  }
          
                  /// <summary>
                  /// 向觀察者(們)發出通知
                  /// </summary>
                  public void Notify()
                  {
                      foreach (Observer o in observers)
                      {
                          o.Update();
                      }
                  }
              }
          
              /// <summary>
              /// 抽象觀察者類,為所有具體觀察者定義一個接口,在得到通知時更新自己
              /// </summary>
              public abstract class Observer
              {
                  public abstract void Update();
              }
          
              /// <summary>
              /// 具體觀察者或具體通知者,將有關狀態存入具體觀察者對象;在具體主題的內部狀態改變時,給所有登記過的觀察者發出通知。具體主題角色通常用一個具體子類實現。
              /// </summary>
              public class ConcreteSubject : Subject
              {
                  private string subjectState;
          
                  /// <summary>
                  /// 具體觀察者的狀態
                  /// </summary>
                  public string SubjectState
                  {
                      get { return subjectState; }
                      set { subjectState = value; }
                  }
              }
          
              /// <summary>
              /// 具體觀察者,實現抽象觀察者角色所要求的更新接口,已是本身狀態與主題狀態相協調
              /// </summary>
              public class ConcreteObserver : Observer
              {
                  private string observerState;
                  private string name;
                  private ConcreteSubject subject;
          
                  /// <summary>
                  /// 具體觀察者用一個具體主題來實現
                  /// </summary>
                  public ConcreteSubject Subject
                  {
                      get { return subject; }
                      set { subject = value; }
                  }
          
                  public ConcreteObserver(ConcreteSubject subject, string name)
                  {
                      this.subject = subject;
                      this.name = name;
                  }
          
                  /// <summary>
                  /// 實現抽象觀察者中的更新操作
                  /// </summary>
                  public override void Update()
                  {
                      observerState = subject.SubjectState;
                      Console.WriteLine("The observer's state of {0} is {1}", name, observerState);
                  }
              }
          復制代碼

            4.3 客戶端代碼

          復制代碼
              class Program
              {
                  static void Main(string[] args)
                  {
                      // 具體主題角色通常用具體自來來實現
                      ConcreteSubject subject = new ConcreteSubject();
          
                      subject.Attach(new ConcreteObserver(subject, "Observer A"));
                      subject.Attach(new ConcreteObserver(subject, "Observer B"));
                      subject.Attach(new ConcreteObserver(subject, "Observer C"));
          
                      subject.SubjectState = "Ready";
                      subject.Notify();
          
                      Console.Read();
                  }
              }
          復制代碼

            運行結果

            

          5. 模式總結

            5.1 優點

              5.1.1 觀察者模式解除了主題和具體觀察者的耦合,讓耦合的雙方都依賴于抽象,而不是依賴具體。從而使得各自的變化都不會影響另一邊的變化。

            5.2 缺點

              5.2.1 依賴關系并未完全解除,抽象通知者依舊依賴抽象的觀察者。

            5.3 適用場景

              5.3.1 當一個對象的改變需要給變其它對象時,而且它不知道具體有多少個對象有待改變時。

              5.3.2 一個抽象某型有兩個方面,當其中一個方面依賴于另一個方面,這時用觀察者模式可以將這兩者封裝在獨立的對象中使它們各自獨立地改變和復用。

           

          6. 模式引申,應用C#中的事件委托來徹底解除通知者和觀察者之間的耦合。

             6.1 關于委托的定義:委托是一種引用方法的類型。一旦為委托分配了方法,委托將與該方法有相同的行為。委托方法可以像其它任何方法一樣,具有參數和返回值。委托可以看作是對函數(方法)的的抽象,是函數的“類”,委托的實例代表一個(或多個)具體的函數,它可以是多播的。

             6.2 關于事件:事件基于委托,為委托提供了一種發布/訂閱機制。事件的訂閱與取消與我們剛才講的觀察者模式中的訂閱與取消類似,只是表現形式有所不同。在觀察者模式中,訂閱使用方法Attach()來進行;在事件的訂閱中使用“+=”。類似地,取消訂閱在觀察者模式中用Dettach(),而事件的取消用“-=”。

           

          7. 下面例子分別用觀察者模式,事件機制來實現

            7.1 實例描述:客戶支付了訂單款項,這時財務需要開具發票,出納需要記賬,配送員需要配貨。

            7.2 觀察者模式的實現

              7.2.1 類圖

              

              7.2.2 代碼實現

          復制代碼
              /// <summary>
              /// 抽象觀察者
              /// </summary>
              public interface ISubject
              {
                  void Notify();
              }
          
              /// <summary>
              /// 工作崗位,作為這里的觀察者的抽象
              /// </summary>
              public abstract class JobStation
              {
                  public abstract void Update();
              }
          
              /// <summary>
              /// 具體主題,這里是客戶
              /// </summary>
              public class Customer : ISubject
              {
                  private string customerState;
          
                  private IList<JobStation> observers = new List<JobStation>();
          
                  /// <summary>
                  /// 增加觀察者
                  /// </summary>
                  /// <param name="observer"></param>
                  public void Attach(JobStation observer)
                  {
                      this.observers.Add(observer);
                  }
          
                  /// <summary>
                  /// 移除觀察者
                  /// </summary>
                  /// <param name="observer"></param>
                  public void Detach(JobStation observer)
                  {
                      this.observers.Remove(observer);
                  }
          
                  /// <summary>
                  /// 客戶狀態
                  /// </summary>
                  public string CustomerState
                  {
                      get { return customerState; }
                      set { customerState = value; }
                  }
          
                  public void Notify()
                  {
                      foreach (JobStation o in observers)
                      {
                          o.Update();
                      }
                  }
              }
          
              /// <summary>
              /// 會計
              /// </summary>
              public class Accountant : JobStation
              {
                  private string accountantState;
                  private Customer customer;
          
                  public Accountant(Customer customer)
                  {
                      this.customer = customer;
                  }
          
                  /// <summary>
                  /// 更新狀態
                  /// </summary>
                  public override void Update()
                  {
                      if (customer.CustomerState == "已付款")
                      {
                          Console.WriteLine("我是會計,我來開具發票。");
                          accountantState = "已開發票";
                      }
                  }
              }
          
              /// <summary>
              /// 出納
              /// </summary>
              public class Cashier : JobStation
              {
                  private string cashierState;
                  private Customer customer;
          
                  public Cashier(Customer customer)
                  {
                      this.customer = customer;
                  }
          
                  public override void Update()
                  {
                      if (customer.CustomerState == "已付款")
                      {
                          Console.WriteLine("我是出納員,我給登記入賬。");
                          cashierState = "已入賬";
                      }
                  }
              }
          
              /// <summary>
              /// 配送員
              /// </summary>
              public class Dilliveryman : JobStation
              {
                  private string dillivierymanState;
                  private Customer customer;
          
                  public Dilliveryman(Customer customer)
                  {
                      this.customer = customer;
                  }
          
                  public override void Update()
                  {
                      if (customer.CustomerState == "已付款")
                      {
                          Console.WriteLine("我是配送員,我來發貨。");
                          dillivierymanState = "已發貨";
                      }
                  }
              }
          復制代碼

              7.2.3 客戶端代碼

          復制代碼
              class Program
              {
                  static void Main(string[] args)
                  {
          
                      Customer subject = new Customer();
          
                      subject.Attach(new Accountant(subject));
                      subject.Attach(new Cashier(subject));
                      subject.Attach(new Dilliveryman(subject));
          
                      subject.CustomerState = "已付款";
                      subject.Notify();
          
                      Console.Read();
                  }
              }
          復制代碼

              運行結果:

              我是會計,我來開具發票。
              我是出納員,我給登記入賬。
              我是配送員,我來發貨。

           

            7.3 事件實現

              7.3.1 類圖

              

              通過類圖來看,觀察者和主題之間已經不存在任何依賴關系了。

              7.3.2 代碼實現

              

          復制代碼
              /// <summary>
              /// 抽象主題
              /// </summary>
              public interface ISubject
              {
                  void Notify();
              }
          
              /// <summary>
              /// 聲明委托
              /// </summary>
              public delegate void CustomerEventHandler();
          
              /// <summary>
              /// 具體主題
              /// </summary>
              public class Customer : ISubject
              {
                  private string customerState;
          
                  // 聲明一個委托事件,類型為 CustomerEventHandler
                  public event CustomerEventHandler Update;
          
                  public void Notify()
                  {
                      if (Update != null)
                      {
                          // 使用事件來通知給訂閱者
                          Update();
                      }
                  }
          
                  public string CustomerState
                  {
                      get { return customerState; }
                      set { customerState = value; }
                  }
              }
          
              /// <summary>
              /// 財務,已經不需要實現抽象的觀察者類,并且不用引用具體的主題
              /// </summary>
              public class Accountant
              {
                  private string accountantState;
          
                  public Accountant()
                  { }
          
                  /// <summary>
                  /// 開發票
                  /// </summary>
                  public void GiveInvoice()
                  {
                      Console.WriteLine("我是會計,我來開具發票。");
                      accountantState = "已開發票";
                  }
              }
          
              /// <summary>
              /// 出納,已經不需要實現抽象的觀察者類,并且不用引用具體的主題
              /// </summary>
              public class Cashier
              {
                  private string cashierState;
          
                  public void Recoded()
                  {
                      Console.WriteLine("我是出納員,我給登記入賬。");
                      cashierState = "已入賬";
                  }
              }
          
              /// <summary>
              /// 配送員,已經不需要實現抽象的觀察者類,并且不用引用具體的主題
              /// </summary>
              public class Dilliveryman
              {
                  private string dillivierymanState;
          
                  public void Dilliver()
                  {
                      Console.WriteLine("我是配送員,我來發貨。");
                      dillivierymanState = "已發貨";
                  }
              }
          復制代碼

              7.3.3 客戶端代碼

          復制代碼
              class Program
              {
                  static void Main(string[] args)
                  {
          
                      Customer subject = new Customer();
          
                      Accountant accountant = new Accountant();
                      Cashier cashier = new Cashier();
                      Dilliveryman dilliveryman = new Dilliveryman();
          
                      // 注冊事件
                      subject.Update += accountant.GiveInvoice;
                      subject.Update += cashier.Recoded;
                      subject.Update += dilliveryman.Dilliver;
          
                      /*
                       * 以上寫法也可以用下面代碼來替換
                      subject.Update += new CustomerEventHandler(accountant.GiveInvoice);
                      subject.Update += new CustomerEventHandler(cashier.Recoded);
                      subject.Update += new CustomerEventHandler(dilliveryman.Dilliver);
                       */
          
                      subject.CustomerState = "已付款";
                      subject.Notify();
          
                      Console.Read();
                  }
              }
          復制代碼

              運行結果

              我是會計,我來開具發票。
              我是出納員,我給登記入賬。
              我是配送員,我來發貨。

          posted on 2013-08-11 23:41 fly 閱讀(205) 評論(0)  編輯  收藏 所屬分類: 設計模式
          主站蜘蛛池模板: 宝鸡市| 邳州市| 沾化县| 永胜县| 五华县| 淮滨县| 宾阳县| 新和县| 太和县| 彭泽县| 长岭县| 海原县| 平舆县| 锡林郭勒盟| 宁城县| 新民市| 苍溪县| 河津市| 上林县| 连南| 寿阳县| 曲阜市| 拉萨市| 农安县| 五河县| 贡嘎县| 广河县| 滕州市| 竹山县| 兴海县| 兰州市| 青海省| 读书| 土默特右旗| 密山市| 鸡泽县| 蒲城县| 郴州市| 驻马店市| 辽阳市| 班玛县|