观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使他们能够自动更新自己。
特点:
一个对象的改变需要同时改变其他对象,而且不知道具体改变多少对象。
接触耦合,让耦合的双方都依赖于抽象,而不是依赖于具体,从而使格子的变化不会影响另一边的变化。
抽象类:
//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);
}
委托就是一种引用方法的类型。一旦为委托分配了方法,委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样,具有参数和返回值。委托可以看作是对函数的抽象,是函数的“类”,委托的实例将代表一个具体的函数。
委托对象所搭载的所有方法必须具有相同的原形和形式,即拥有相同的参数列表和返回值类型。