设计模式（十）观察者模式

观察者模式（Observer），又叫发布-订阅（Publish/Subscribe）模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

当一个对象的改变需要同时改变其他对象，而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。或者说，当一个抽象模型由两个方面，其中一方面依赖于另一方面，此时用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。

观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不依赖于具体。从而使得各自的变化都不会影响另一边的变化。

基本代码

// 抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫更新接口。
// 抽象观察者一般用一个抽象类或者一个接口实现。
abstract class Observer
{ 
  // 更新方法
  public abstract void Update();
}

// Subject 类，可翻译为主题或抽象通知者，一般用一个抽象者或者一个接口实现。它把所有对观察者对象的引用保存在一个聚集，
// 每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
abstract class Subject
{
  private IList<Observer> observers = new List<Observer>();

  // 增加观察者
  public void Attach(Observer observer)
  {
    observer.Add(observer);
  }
  // 移除观察者
  public void Detach(Observer observer)
  {
    observer.Remove(observer);
  }
  // 通知
  public void Notify()
  {
    foreach(Observer o in observers)
    {
      o.Update();
    } 
  }
}

// 具体主题或具体通知者，将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。
class ConcreteSubject : Subject
{
  private string subjectState;
  // 具体被观察者状态
  public string SubjectState
  {
    get { return subjectState; }
    set { subjectState = value; }
  }
}

// 具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。
// 具体观察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现
class ConcreteObserver : Observer
{
  private string name;
  private string observerState;
  private ConcreteSubject subject;

  public ConcreteObserver(ConcreteSubject subject, string name)
  {
    this.subject = subject;
    this.name = name;
  }

  public override void Update()
  {
    observerState = subject.SubjectState;
    Console.WriteLine("观察者{0}的新状态是{1}", name, observerState);
  }

  public ConcreteSubject Subject
  {
    get { return subject; }
    set { subject = value; }
  }
}

// 客户端
static void Main(string[] args)
{
  ConcreteSubject s = new ConcreteSubject();

  s.Attach(new ConcreteObserver(s, "X"));
  s.Attach(new ConcreteObserver(s, "Y"));
  s.Attach(new ConcreteObserver(s, "Z"));

  s.SubjectState = "ABC";
  s.Notify();

  Console.Read();
}

【例】

事件委托

委托就是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的 “类”，委托的实例将代表一个具体的函数。

委托对象所搭载的所有方法必须具有相同的原形和形式，也就是拥有相同的参数列表和返回值类型。

delegate void EventHandler(); 可以理解为声明了一个特殊的 “类”；

public event EventHandler Update;  可以理解为声明了一个 “类” 的变量。

new EventHandler(tongshi1.CloseStockMarket); 一个委托的实例，代表一个具体的函数。

一旦为委托分配了方法，委托将与该方法具有完全相同的行为。而且，一个委托可以搭载多个方法，所有方法被依次唤起。更重要的是，它可以使得委托对象所搭载的方法并不需要属于同一个类。

基本代码

 

// 看股票的同事
class StockObserver
{
  private string name;
  private Subject sub;

  public StockObserver(string name, Subject sub)
  {
    this.name = name;
    this.sub = sub;
  }

  // 关闭股票行情
  public void CloseStockMarket()
  {
    Console.WriteLine(" ");
  }
}

// 看 NBA 的同事
class NBAObserver
{
  private string name;
  private Subject sub;

  public NBAObserver(string name, Subject sub)
  {
    this.name = name;
    this.sub = sub;
  }

  // 关闭 NBA 直播
  public void CloseNBADirectSeeding()
  {
    Console.WriteLine(" ");
  }
}

// 通知者接口
interface Subject
{
  void Notify();

  string SubjectState
  {
    get {};
    set {};
  }
}

// 声明一个委托，事件处理程序，无参数，无返回值
delegate void EventHandler();

// 老板类
class Boss : Subject
{
  // 声明一事件 Update，类型为委托 EventHandler
  public event EventHandler Update;
  private string action;

  public void Notify()
  {
    Update();
  }

  public string SubjectState
  {
    get { return action; }
    set { action = value; }
  }
}

// 前台秘书类
class Secretary : Subject
{
}

// 客户端
Boss boss = new Boss();

// 看股票的同事
StockObserver tongshi1 = new StockObserver("魏", boss);

// 看 NBA 的同事
NBAObserver tongshi2 = new NBAObserver("易", boss);

boss.Update += new EventHandler(tongshi1.CloseStockMarket);
boss.Update += new EventHandler(tongshi2.CloseNBADirectSeeding);

//
boss.SubjectState = "work";

// 发出通知
boss.Notify();