意图:  定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

适用性: 

当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

namespace Observer_DesignPattern
{
    using System;
    using System.Collections;

class Subject
{
private ArrayList list = new ArrayList();

private string strImportantSubjectData = “Initial”;

public string ImportantSubjectData
{
get
{
return strImportantSubjectData;
}
set
{
strImportantSubjectData = value;
}
}

public void Attach(Observer o)
{
list.Add(o);
o.ObservedSubject = this;
}

public void Detach(Observer o)
{

}

public void Notify()
{
foreach (Observer o in list)
{
o.Update();
}
}
}

class ConcreteSubject : Subject
{
public void GetState()
{

}

public void SetState()
{

}
}

abstract class Observer
{
protected Subject s;
public Subject ObservedSubject
{
get
{
return s;
}
set
{
s = value;
}
}
abstract public void Update();
}

class ConcreteObserver : Observer
{
private string observerName;

public ConcreteObserver(string name)
{
observerName = name;
}

override public void Update()
{
Console.WriteLine(“In Observer {0}: data from subject = {1}”,
observerName, s.ImportantSubjectData);
}
}

    /// <summary>
    ///    Summary description for Client.
    /// </summary>
    public class Client
    {    
        public static int Main(string[] args)
        {         
// Set up everything
ConcreteSubject s = new ConcreteSubject();
ConcreteObserver o1 = new ConcreteObserver(“first observer”);
ConcreteObserver o2 = new ConcreteObserver(“second observer”);

s.Attach(o1);
s.Attach(o2);

// make changes to subject
s. ImportantSubjectData = “This is important subject data”;

// Notify all observers
s.Notify();
             return 0;
        }
    }