Observer (***) high -优快云博客

Observer : A way of notifying change to a number of classes

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

MVC 结构和 MFC 的 Frame/Doc/View 的都是 Observer 模式 .

当然， MVC 只是 Observer 模式的一个实例。 Observer 模式要解决的问题为：建立一个

一（ Subject ）对多（ Observer ）的依赖关系，并且做到当“ 变化的时候，依赖这个“

的多也能够同步改变。最常见的一个例子就是：对同一组数据进行统计分析时候，我们希望

能够提供多种形式的表示（例如以表格进行统计显示、柱状图统计显示、百分比统计显示等）。

这些表示都依赖于同一组数据，我们当然需要当数据改变的时候，所有的统计的显示都能够

同时改变。 Observer 模式就是解决了这一个问题。

The classes and/or objects participating in this pattern are:

Subject (Stock)
- knows its observers. Any number of Observer objects may observe a subject
- provides an interface for attaching and detaching Observer objects.
ConcreteSubject (IBM)
- stores state of interest to ConcreteObserver
- sends a notification to its observers when its state changes
Observer (IInvestor)
- defines an updating interface for objects that should be notified of changes in a subject.
ConcreteObserver (Investor)
- maintains a reference to a ConcreteSubject object
- stores state that should stay consistent with the subject's
- implements the Observer updating interface to keep its state consistent with the subject's

This real-world code demonstrates the Observer pattern in which registered investors are notified every time a stock changes value.

// Observer pattern -- Real World example

using System;
using System.Collections;

namespace DoFactory.GangOfFour.Observer.RealWorld
{

  // MainApp test application

  class MainApp
  {
    static void Main()
    {
      // Create investors
      Investor s = new Investor("Sorros");
      Investor b = new Investor("Berkshire");

      // Create IBM stock and attach investors
      IBM ibm = new IBM("IBM", 120.00);
      ibm.Attach(s);
      ibm.Attach(b);

      // Change price, which notifies investors
      ibm.Price = 120.10;
      ibm.Price = 121.00;
      ibm.Price = 120.50;
      ibm.Price = 120.75;

      // Wait for user
      Console.Read();
    }
  }

  // "Subject"

  abstract class Stock
  {
    protected string symbol;
    protected double price;
    private ArrayList investors = new ArrayList();

    // Constructor
    public Stock(string symbol, double price)
    {
      this.symbol = symbol;
      this.price = price;
    }

    public void Attach(Investor investor)
    {
      investors.Add(investor);
    }

    public void Detach(Investor investor)
    {
      investors.Remove(investor);
    }

    public void Notify()
    {
      foreach (Investor investor in investors)
      {
        investor.Update(this);
      }
      Console.WriteLine("");
    }

    // Properties
    public double Price
    {
      get{ return price; }
      set
      {
        price = value;
        Notify();
      }
    }

    public string Symbol
    {
      get{ return symbol; }
      set{ symbol = value; }
    }
  }

  // "ConcreteSubject"

  class IBM : Stock
  {
    // Constructor
    public IBM(string symbol, double price)
      : base(symbol, price)
    {
    }
  }

  // "Observer"

  interface IInvestor
  {
    void Update(Stock stock);
  }

  // "ConcreteObserver"

  class Investor : IInvestor
  {
    private string name;
    private Stock stock;

    // Constructor
    public Investor(string name)
    {
      this.name = name;
    }

    public void Update(Stock stock)
    {
      Console.WriteLine("Notified {0} of {1}'s " +
        "change to {2:C}", name, stock.Symbol, stock.Price);
    }

    // Property
    public Stock Stock
    {
      get{ return stock; }
      set{ stock = value; }
    }
  }
}

Output

Notified Sorros of IBM's change to $120.10
Notified Berkshire of IBM's change to $120.10

Notified Sorros of IBM's change to $121.00
Notified Berkshire of IBM's change to $121.00

Notified Sorros of IBM's change to $120.50
Notified Berkshire of IBM's change to $120.50

Notified Sorros of IBM's change to $120.75
Notified Berkshire of IBM's change to $120.75