设计模式--观察者模式（Publish/Subscribe Mode）

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

    特点：

一个对象的改变需要同时改变其他对象，而且不知道具体改变多少对象。

接触耦合，让耦合的双方都依赖于抽象，而不是依赖于具体，从而使格子的变化不会影响另一边的变化。

抽象类：

 

//Subject

abstract class Subject

{

private IList<Observer> observers =new List<Observer>;

 

//Add Observer

public void Attach(Observer observer)

{

observers.Add(observer);

}

 

//Detach Observer

public void Detach(Observer observer)

{

observers.Remove(observer);

}

 

//Notify

public void Notify()

{

foreach(Observer o in observers)

{

o.Update();

}

}

}

 

//Observer

abstract class Observer

{

public abstract void Update();

}

 

//ConcreteSubject

class ConcreteSubject : Subject

{

private string subjectState;

public string SubjectState

{

get { return subjectState; }

set { subjectState = value; }

}

}

 

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

}

 

public ConcreteSubject Subject

{

get { return subject; }

set { subject = value; }

}

}

 

接口：

interface Observer

{

void Update();

}

 

 

使用委托（不依赖抽象观察者）：

 

 

interface Subject

{

void Notify();

String SubjectState

{

get;

set;

}

}

 

 

声明一个委托

delegate void EventHandler();

 

class ConcreteSubject: Subject

{

...

public event EventHandler Update;//声明EventHandler的委托事件Update

public void Notify()

{

Update();

}

...

}

 

class test

{

ConcreteSubject a = new ConcreteSubject();

ConcreteObserver b = new ConcreteObserver("bbbbb", a);

a.Update += new EventHandler(b.Update);

}

 

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

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