/// <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);
 }
 }

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

 /// <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 = "已发货";
  }
 }
 }

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

 /// <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 = "已发货";
 }
 }

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