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

人话：观察者模式就像公司里老板突然来视察。员工平时可能在摸鱼，但如果老板来了就必须马上开始工作。不过员工不能及时发现老板来了，于是员工贿赂了一个前台负责通风报信。只要老板一进公司，前台就会把消息发给那些加入了通知名单的员工，这些员工收到消息后就会立刻切换状态开始认真工作。

在软件中也是类似的：当某个对象的状态发生变化时，它会通知所有已经登记的观察者对象，让它们及时做出相应的更新。

观察者模式（Observer）结构图

Subject 类（抽象主题 / 通知者）：

//
public abstract class Subject
{
    private IList<Observer> observers = new List<Observer>();

    // 添加观察者
    public void Attach(Observer observer)
    {
        observers.Add(observer);
    }

    // 移除观察者
    public void Detach(Observer observer)
    {
        observers.Remove(observer);
    }

    // 通知所有观察者
    public void Notify()
    {
        foreach (Observer o in observers)
        {
            o.Update();
        }
    }
}

ConcreteSubject 类（具体主题）：

public class ConcreteSubject : Subject
{
    private string subjectState;

    // 被观察者状态
    public string SubjectState
    {
        get { return subjectState; }
        set { subjectState = value; }
    }
}

Observer 类（抽象观察者）：

public abstract class Observer
{
    public abstract void Update();
}

ConcreteObserver 类（具体观察者）：

public 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; }
    }
}

客户端代码：

class Program
{
    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();
    }
}

观察者 X 的新状态是 ABC
观察者 Y 的新状态是 ABC
观察者 Z 的新状态是 ABC

• 观察者模式的动机：将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩和重用都带来不便。而观察者模式的关键对象是主题Subject和观察者Observer，一个Subject可以有任意数目的依赖它的Observer，一旦Subject的状态发生了改变，所有Observer都可以得到通知。Subject发出通知时并不需要知道谁是它的观察者，也就是说，具体观察者是谁，它根本不需要知道。而任何一个具体观察者不知道也不需要知道其他观察者的存在。

什么时候考虑使用观察者模式呢？

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

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

• 那么抽象观察者可不可以用接口来定义？ 现实编程中，具体的观察者完全有可能是风马牛不相及的类，但它们都需要根据通知者的通知来做出Update()的操作，所以让它们都实现下面这样的一个接口就可以实现这个想法了。

interface Observer
{
    void Update();
}