设计模式之观察者模式

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

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

下面的代码利用了委托。我对委托的定义就是函数指针。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式
{
delegate void EventHandler();
interface Object
{
string State
{
get;
set;
}
void Notify();
}
class AObject:Object
{
private string state;
public event EventHandler update;
public string State
{
get
{
return state;
}
set
{
state = value;
}
}
public void Notify()
{
update();
}
}
class BObject : Object
{
private string state;
public event EventHandler update;
public string State
{
get
{
return state;
}
set
{
state = value;
}
}
public void Notify()
{
update();
}
}
class ManA
{
public string name;
public Object obj;
public ManA(string Name,Object Obj)
{
this.name = Name;
this.obj = Obj;
}
public void updateA()
{
Console.WriteLine("{0},{1},关掉电视",obj.State,name);
}
}
class ManB
{
public string name;
public Object obj;
public ManB(string Name,Object Obj)
{
this.name = Name;
this.obj = Obj;
}
public void updateB()
{
Console.WriteLine("{0},{1},关掉手机",obj.State,name);
}
}
class Program
{
static void Main(string[] args)
{
AObject a = new AObject();
a.State = "我是A";
ManA am = new ManA("am", a);
ManB bm = new ManB("bm", a);
a.update += new EventHandler(am.updateA);
a.update += new EventHandler(bm.updateB);
a.Notify();
BObject b = new BObject();
b.State = "我是B";
ManA cm = new ManA("cm", b);
ManB dm = new ManB("dm",b);
b.update += new EventHandler(cm.updateA);
b.update += new EventHandler(dm.updateB);
b.Notify();
Console.Read();
}
}
}

输出结果：