现实生活中存在很多观察者模式的实例，对于我们的理解和学习存在很大的帮助。最简单的例子，我们每天都使用Windows系统，用户界面和窗体之间，不同的状态发生不同的变化就是很好的观察者模式。
观察者模式（Observer）结构图:
场景：老板胡汉三回来了，通知员工，继续工作！
定义抽象的通知者接口
//抽象通知者接口
interface Subject
{
void Attach(Observer observer);
void Detach(Observer observer);
void Notify();
string SubjectState
{
get;
set;
}
}
定义具体的通知者老板类
//老板类
class Boss : Subject
{
//同事列表
private IList <Observer >observers=new List<Observer >();
private string action;
//增加
public void Attach(Observer observer)
{
observers.Add(observer);
}
//减少
public void Detach(Observer observer)
{
observers.Remove(observer );
}
//通知
public void Notify()
{
foreach (Observer o in observers)
o.Update();
}
//老板状态
public string SubjectState
{
get { return action; }
set { action = value; }
}
}
定义抽象的观察者
//抽象观察者
abstract class Observer
{
protected string name;
protected Subject sub;
public Observer (string name,Subject sub)
{
this.name=name;
this.sub=sub;
}
public abstract void Update();
}
定义具体的被观察者
//看股票的同事
class StockObserver : Observer
{
public StockObserver(string name, Subject sub)
: base(name, sub)
{
}
public override void Update()
{
Console.WriteLine ("{0}{1}关闭股票行情，继续工作！",sub.SubjectState ,name);
}
}
//看NBA的同事
class NBAObserver : Observer
{
public NBAObserver(string name, Subject sub)
: base(name, sub)
{
}
public override void Update()
{
Console.WriteLine ("{0}{1}关闭NBA直播，继续工作！",sub.SubjectState ,name);
}
}
应用程序的主函数：
class Program
{
static void Main(string[] args)
{
//老板胡汉三
Boss huhansan = new Boss();
//看股票的同事
StockObserver tongshi1 = new StockObserver("魏关姹",huhansan );
//看NBA直播的同事
NBAObserver tongshi2 = new NBAObserver("易管查",huhansan );
huhansan.Attach(tongshi1);
huhansan.Attach(tongshi2 );
huhansan.Detach(tongshi1);
//老板回来了
huhansan.SubjectState = "我胡汉三回来了！";
//发出通知
huhansan.Notify();
}
}
观察者模式定义了对象间的一对多的依赖关系，当对象的状态发生改变时，所有依赖于他的对象都得到通知并自动更新。
观察者模式的实现，一般有下面四部分组成:
1.Subject接口（抽象目标）:含方法Notify,Attach,Detach(名字可以自己任意取名)
2.ConcreteSubject类（实体目标）:实现Subject接口
3.Observable接口（抽象观察者）。
4 ConcreteObserver类（实体观察者）:实现Observable接口，一般有多个。
观察者模式优缺点：
1.观察者模式的优点：
（1）.观察者模式完美的将观察者和被观察的对象分离开。举个例子：用户界面可以作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示在界面上。
（2）.观察者模式在模块之间划定了清晰的界限，提高了应用程序的可维护性和重用性。
2.观察者模式还存在不足之处
万一没有了抽象观察者接口，通知功能就完成不了；每个具体观察者，不一定是“更新”的方法实现调用。
委托就可以很好的解决观察者模式的不足：
例如：
场景：同上
//通知者接口
interface Subject
{
void Notify();
string SubjectState
{
get;
set;
}
}
//声明一个委托
delegate void EventHandler();
class Boss : Subject
{
//声明一事件Update，类型为委托EventHandler
public event EventHandler Update;
private string action;
public void Notify()
{
Update(); //访问通知时调用更新
}
public string SubjectState
{
get { return action; }
set { action = value; }
}
}
//看股票的同事
class StockObserver
{
private string name;
private Subject sub;
public StockObserver(string name, Subject sub)
{
this.name = name;
this.sub = sub;
}
//关闭股票行情
public void CloseStockMarket()
{
Console.WriteLine("{0}{1}关闭股票行情，继续工作！", sub.SubjectState, name);
}
}
//看NBA的同事
class NBAObserver
{
private string name;
private Subject sub;
public NBAObserver(string name, Subject sub)
{
this.name = name;
this.sub = sub;
}
//关闭NBA直播
public void CloseNBADirectSeeding()
{
Console.WriteLine("{0}{1}关闭NBA直播，继续工作！", sub.SubjectState, name);
}
}
程序主函数：
class Program
{
static void Main(string[] args)
{
//老板胡汉三
Boss huhansan=new Boss ();
//看股票同事
StockObserver tongshi1 = new StockObserver("魏关姹",huhansan );
//看NBA的同事
NBAObserver tongshi2 = new NBAObserver("易管查",huhansan );
huhansan.Update += new EventHandler(tongshi1.CloseStockMarket);
huhansan.Update += new EventHandler(tongshi2.CloseNBADirectSeeding );
//老板回来
huhansan.SubjectState = "我胡汉三回来了！";
//发送通知
huhansan.Notify();
}
}
委托就是一种引用方法的类型，一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看做是对函数的抽象，是函数的一个类，委托实例代表一个具体的函数，而且一个委托可以搭载多个方法，所有方法被依次唤醒。