观察者模式(Observer Pattern)
.NET设计模式系列文章
(薛敬明的专栏)
乐在其中设计模式(C#)
设计模式（19）－Observer Pattern
一、 观察者（Observer）模式
观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作（Collaboration）。观察者模式是满足这一要求的各种设计方案中最重要的一种。
二、 观察者模式的结构
观察者模式的类图如下：
可以看出，在这个观察者模式的实现里有下面这些角色：
- 抽象主题（Subject）角色：主题角色把所有对观察考对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫做抽象被观察者（Observable）角色，一般用一个抽象类或者一个接口实现。
- 抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中，更新接口只包含一个方法（即Update()方法），这个方法叫做更新方法。
- 具体主题（ConcreteSubject）角色：将有关状态存入具体现察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色（Concrete Observable）。具体主题角色通常用一个具体子类实现。
- 具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。
从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做"针对抽象编程"。
三、 观察者模式的示意性源代码
//
Observer pattern -- Structural example
using
System;
using
System.Collections;
//
"Subject"
abstract
class
Subject
{
// Fields private ArrayList observers = new ArrayList(); // Methods 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(); }
}
//
"ConcreteSubject"
class
ConcreteSubject : Subject
{ // Fields private string subjectState; // Properties public string SubjectState { get{ return subjectState; } set{ subjectState = value; } }}
//
"Observer"
abstract
class
Observer
{ // Methods abstract public void Update();}
//
"ConcreteObserver"
class
ConcreteObserver : Observer
{ // Fields private string name; private string observerState; private ConcreteSubject subject; // Constructors public ConcreteObserver( ConcreteSubject subject, string name ) { this.subject = subject; this.name = name; } // Methods override public void Update() { observerState = subject.SubjectState; Console.WriteLine( "Observer {0}'s new state is {1}", name, observerState ); } // Properties public ConcreteSubject Subject { get { return subject; } set { subject = value; } }}
/// <summary>/// Client test/// </summary>
public
class
Client
{ public static void Main( string[] args ) { // Configure Observer structure ConcreteSubject s = new ConcreteSubject(); s.Attach( new ConcreteObserver( s, "1" ) ); s.Attach( new ConcreteObserver( s, "2" ) ); s.Attach( new ConcreteObserver( s, "3" ) ); // Change subject and notify observers s.SubjectState = "ABC"; s.Notify(); }}
四、 C#中的Delegate与Event
实际上在C#中实现Observer模式没有这么辛苦，.NET中提供了Delegate与Event机制，我们可以利用这种机制简化Observer模式。关于Delegate与Event的使用方法请参考相关文档。改进后的Observer模式实现如下：
//
Observer pattern -- Structural example
using
System;
//
Delegate
delegate
void
UpdateDelegate();
//
Subject
class
Subject
{ public event UpdateDelegate UpdateHandler; // Methods public void Attach( UpdateDelegate ud ) { UpdateHandler += ud; } public void Detach( UpdateDelegate ud ) { UpdateHandler -= ud; } public void Notify() { if(UpdateHandler != null) UpdateHandler(); }}
//
ConcreteSubject
class
ConcreteSubject : Subject
{ // Fields private string subjectState; // Properties public string SubjectState { get{ return subjectState; } set{ subjectState = value; } }}
//
"ConcreteObserver"
class
ConcreteObserver
{ // Fields private string name; private string observerState; private ConcreteSubject subject; // Constructors public ConcreteObserver( ConcreteSubject subject, string name ) { this.subject = subject; this.name = name; } // Methods public void Update() { observerState = subject.SubjectState; Console.WriteLine( "Observer {0}'s new state is {1}", name, observerState ); } // Properties public ConcreteSubject Subject { get { return subject; } set { subject = value; } }}
//
"ConcreteObserver"
class
AnotherObserver
{ // Methods public void Show() { Console.WriteLine("AnotherObserver got an Notification!"); }}
public
class
Client
{ public static void Main(string[] args) { ConcreteSubject s = new ConcreteSubject(); ConcreteObserver o1 = new ConcreteObserver(s, "1"); ConcreteObserver o2 = new ConcreteObserver(s, "2"); AnotherObserver o3 = new AnotherObserver(); s.Attach(new UpdateDelegate(o1.Update)); s.Attach(new UpdateDelegate(o2.Update)); s.Attach(new UpdateDelegate(o3.Show)); s.SubjectState = "ABC"; s.Notify(); Console.WriteLine("--------------------------"); s.Detach(new UpdateDelegate(o1.Update)); s.SubjectState = "DEF"; s.Notify(); }}
其中，关键的代码如下：
delegate
void
UpdateDelegate();
定义一个Delegate，用来规范函数结构。不管是ConcreteObserver类的Update方法还是AnotherObserver类的Show方法都符合该Delegate。这不象用Observer接口来规范必须使用Update方法那么严格。只要符合Delegate所指定的方法结构的方法都可以在后面被事件所处理。
public
event
UpdateDelegate UpdateHandler;
定义一个事件，一旦触发，可以调用一组符合UpdateDelegate规范的方法。
public
void
Attach( UpdateDelegate ud )
{ UpdateHandler += ud; }
订阅事件。只要是一个满足UpdateDelegate的方法，就可以进行订阅操作（如下所示）。
s.Attach(
new
UpdateDelegate(o1.Update)); s.Attach(
new
UpdateDelegate(o2.Update)); s.Attach(
new
UpdateDelegate(o3.Show));
在Notify方法中：
public
void
Notify()
{ if(UpdateHandler != null) UpdateHandler(); }
只要UpdateHandler != null（表示有订阅者），就可以触发事件（UpdateHandler()），所有的订阅者便会接到通知。
五、 一个实际应用观察者模式的例子
该例子演示了注册的投资者在股票市场发生变化时，可以自动得到通知。该例子仍然使用的是传统的Observer处理手段，至于如何转换成Delegate与Event留给读者自己考虑。
//
Observer pattern -- Real World example
using
System;
using
System.Collections;
//
"Subject"
abstract
class
Stock
{ // Fields protected string symbol; protected double price; private ArrayList investors = new ArrayList(); // Constructor public Stock( string symbol, double price ) { this.symbol = symbol; this.price = price; } // Methods public void Attach( Investor investor ) { investors.Add( investor ); } public void Detach( Investor investor ) { investors.Remove( investor ); } public void Notify() { foreach( Investor i in investors ) i.Update( this ); } // Properties public double Price { get{ return price; } set { price = value; Notify(); } } public string Symbol { get{ return symbol; } set{ symbol = value; } }}
//
"ConcreteSubject"
class
IBM : Stock
{ // Constructor public IBM( string symbol, double price ) : base( symbol, price ) {}}
//
"Observer"
interface
IInvestor
{ // Methods void Update( Stock stock );}
//
"ConcreteObserver"
class
Investor : IInvestor
{ // Fields private string name; private string observerState; private Stock stock; // Constructors public Investor( string name ) { this.name = name; } // Methods public void Update( Stock stock ) { Console.WriteLine( "Notified investor {0} of {1}'s change to {2:C}", name, stock.Symbol, stock.Price ); } // Properties public Stock Stock { get{ return stock; } set{ stock = value; } }}
/// <summary>/// ObserverApp test/// </summary>
public
class
ObserverApp
{ public static void Main( string[] args ) { // Create investors Investor s = new Investor( "Sorros" ); Investor b = new Investor( "Berkshire" ); // Create IBM stock and attach investors IBM ibm = new IBM( "IBM", 120.00 ); ibm.Attach( s ); ibm.Attach( b ); // Change price, which notifies investors ibm.Price = 120.10; ibm.Price = 121.00; ibm.Price = 120.50; ibm.Price = 120.75; }}
六、 观察者模式的优缺点
Observer模式的优点是实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰，并抽象了更新接口，使得可以有各种各样不同的表示层（观察者）。
但是其缺点是每个外观对象必须继承这个抽像出来的接口类，这样就造成了一些不方便，比如有一个别人写的外观对象，并没有继承该抽象类，或者接口不对，我们又希望不修改该类直接使用它。虽然可以再应用Adapter模式来一定程度上解决这个问题，但是会造成更加复杂烦琐的设计，增加出错几率。
观察者模式的效果有以下几个优点：
（1）观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体现察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。
（2）观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。
观察者模式有下面的一些缺点：
（1）如果一个被观察者对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
（2）如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察考模式时要特别注意这一点。
（3）如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。
（4）虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。
参考文献：
阎宏，《Java与模式》，电子工业出版社
[美]James W. Cooper，《C#设计模式》，电子工业出版社
[美]Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社
[美]Robert C. Martin，《敏捷软件开发－原则、模式与实践》，清华大学出版社
[美]Don Box, Chris Sells，《.NET本质论 第1卷：公共语言运行库》，中国电力出版社
.NET设计模式（19）：观察者模式（Observer Pattern）
概述
在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系” ——一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。
意图
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。[GOF 《设计模式》]
结构图
图1 Observer模式结构图
生活中的例子
观察者定义了对象间一对多的关系，当一个对象的状态变化时，所有依赖它的对象都得到通知并且自动地更新。拍卖演示了这种模式。每个投标人都有一个标有数字的牌子用于出价。拍卖师开始拍卖时，他观察是否有牌子举起出价。每次接受一个新的出价都改变了拍卖的当前价格，并且广播给所有的投标人进行新的出价。
图2 使用拍卖例子的观察者模式
Observer模式解说
下面通过一个例子来说明Observer模式。监控某一个公司的股票价格变化，可以有多种方式，通知的对象可以是投资者，或者是发送到移动设备，还有电子邮件等。一开始我们先不考虑Observer模式，通过一步步地重构，最终重构为Observer模式。现在有这样两个类：Microsoft和Investor，如下图所示：
图3 UML静态图示例
它们的实现如下：
public
class
Microsoft
{ private Investor _investor; private String _symbol; private double _price; public void Update() { _investor.SendData(this); } public Investor Investor { get { return _investor; } set { _investor = value; } } public String Symbol { get { return _symbol; } set { _symbol = value; } } public double Price { get { return _price; } set { _price = value; } }}
public
class
Investor
{ private string _name; public Investor(string name) { this._name = name; } public void SendData(Microsoft ms) { Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", _name, ms.Symbol,ms.Price); }}
简单的客户端实现：
class
Program
{ static void Main(string[] args) { Investor investor = new Investor("Jom"); Microsoft ms = new Microsoft(); ms.Investor = investor; ms.Symbol = "Microsoft"; ms.Price = 120.00; ms.Update(); Console.ReadLine(); }}
运行后结果如下：
Notified Jom of Microsoft's change to ￥120
可以看到，这段代码运行并没有问题，也确实实现了我们最初的设想的功能，把Microsoft的股票价格变化通知到了Jom投资者那儿。但是这里面出现了如下几个问题：
1．Microsoft和Investor之间形成了一种双向的依赖关系，即Microsoft调用了Investor的方法，而Investor调用了Microsoft类的属性。如果有其中一个类变化，有可能会引起另一个的变化。
2．当出现一种的通知对象，比如说是移动设备Mobile：
public
class
Mobile
{ private string _no; public Mobile(string No) { this._no = No; } public void SendData(Microsoft ms) { Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", _no, ms.Symbol, ms.Price); }}
这时候对应的Microsoft的类就应该改变为如下代码，在Microsot类中增加Mobile，同时修改Update()方法使其可以通知到移动设备：
public
class
Microsoft
{ private Investor _investor; private Mobile _mobile; private String _symbol; private double _price; public void Update() { _investor.SendData(this); _mobile.SendData(this); } public Mobile Mobile { get { return _mobile; } set { _mobile = value; } } public Investor Investor { get { return _investor; } set { _investor = value; } } public String Symbol { get { return _symbol; } set { _symbol = value; } } public double Price { get { return _price; } set { _price = value; } }}
显然这样的设计极大的违背了“开放-封闭”原则，这不是我们所想要的，仅仅是新增加了一种通知对象，就需要对原有的Microsoft类进行修改，这样的设计是很糟糕的。对此做进一步的抽象，既然出现了多个通知对象，我们就为这些对象之间抽象出一个接口，用它来取消Microsoft和具体的通知对象之间依赖。
图4 静态UML图示例
实现代码如下：
public
interface
IObserver
{ void SendData(Microsoft ms);}
public
class
Investor : IObserver
{ private string _name; public Investor(string name) { this._name = name; } public void SendData(Microsoft ms) { Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", _name, ms.Symbol,ms.Price); }}
public
class
Microsoft
{ private IObserver _investor; private String _symbol; private double _price; public void Update() { _investor.SendData(this); } public String Symbol { get { return _symbol; } set { _symbol = value; } } public double Price { get { return _price; } set { _price = value; } } public IObserver Investor { get { return _investor; } set { _investor = value; } }}
做到这一步，可以看到，我们在降低两者的依赖性上已经迈进了一小步，正在朝着弱依赖性这个方向变化。在Microsoft类中已经不再依赖于具体的Investor，而是依赖于接口IObserver。
但同时我们看到，再新出现一个移动设备这样的通知对象，Microsoft类仍然需要改变，对此我们再做如下重构，在Microsoft中维护一个IObserver列表，同时提供相应的维护方法。
图5 静态UML示例图
Microsoft类的实现代码如下：
public
class
Microsoft
{ private List<IObserver> observers = new List<IObserver>(); private String _symbol; private double _price; public void Update() { foreach (IObserver ob in observers) { ob.SendData(this); } } public void AddObserver(IObserver observer) { observers.Add(observer); } public void RemoveObserver(IObserver observer) { observers.Remove(observer); } public String Symbol { get { return _symbol; } set { _symbol = value; } } public double Price { get { return _price; } set { _price = value; } }}
此时客户端的调用代码：
class
Program
{ static void Main(string[] args) { IObserver investor1 = new Investor("Jom"); IObserver investor2 = new Investor("TerryLee"); Microsoft ms = new Microsoft(); ms.Symbol = "Microsoft"; ms.Price = 120.00; ms.AddObserver(investor1); ms.AddObserver(investor2); ms.Update(); Console.ReadLine(); }}
走到这一步，已经有了Observer模式的影子了，Microsoft类不再依赖于具体的Investor，而是依赖于抽象的IOberver。存在着的一个问题是Investor仍然依赖于具体的公司Microsoft，况且公司还会有很多IBM，Google等，解决这样的问题很简单，只需要再对Microsoft类做一次抽象。如下图所示：
图6 静态UML示例图
实现代码如下：
public
abstract
class
Stock
{ private List<IObserver> observers = new List<IObserver>(); private String _symbol; private double _price; public Stock(String symbol, double price) { this._symbol = symbol; this._price = price; } public void Update() { foreach (IObserver ob in observers) { ob.SendData(this); } } public void AddObserver(IObserver observer) { observers.Add(observer); } public void RemoveObserver(IObserver observer) { observers.Remove(observer); } public String Symbol { get { return _symbol; } } public double Price { get { return _price; } }}
public
class
Microsoft : Stock
{ public Microsoft(String symbol, double price) : base(symbol, price) { }}
public
interface
IObserver
{ void SendData(Stock stock);}
public
class
Investor : IObserver
{ private string _name; public Investor(string name) { this._name = name; } public void SendData(Stock stock) { Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", _name, stock.Symbol,stock.Price); }}
客户端程序代码如下：
class
Program
{ static void Main(string[] args) { Stock ms = new Microsoft("Microsoft",120.00); ms.AddObserver(new Investor("Jom")); ms.AddObserver(new Investor("TerryLee")); ms.Update(); Console.ReadLine(); }}
到这里我们可以看到，通过不断的重构，不断地抽象，我们由一开始的很糟糕的设计，逐渐重构为使用Observer模式的这样一个方案。在这个例子里面，IOberser充当了观察者的角色，而Stock则扮演了主题对象角色，在任何时候，只要调用了Stock的Update()方法，它就会通知它的所有观察者对象。同时可以看到，通过Observer模式，取消了直接依赖，变为间接依赖，这样大大提供了系统的可维护性和可扩展性。
推模式与拉模式
对于发布-订阅模型，大家都很容易能想到推模式与拉模式，用SQL Server做过数据库复制的朋友对这一点很清楚。在Observer模式中同样区分推模式和拉模式，我先简单的解释一下两者的区别：推模式是当有消息时，把消息信息以参数的形式传递（推）给所有观察者，而拉模式是当有消息时，通知消息的方法本身并不带任何的参数，是由观察者自己到主体对象那儿取回（拉）消息。知道了这一点，大家可能很容易发现上面我所举的例子其实是一种推模式的Observer模式。我们先看看这种模式带来了什么好处：当有消息时，所有的观察者都会直接得到全部的消息，并进行相应的处理程序，与主体对象没什么关系，两者之间的关系是一种松散耦合。但是它也有缺陷，第一是所有的观察者得到的消息是一样的，也许有些信息对某个观察者来说根本就用不上，也就是观察者不能“按需所取”；第二，当通知消息的参数有变化时，所有的观察者对象都要变化。鉴于以上问题，拉模式就应运而生了，它是由观察者自己主动去取消息，需要什么信息，就可以取什么，不会像推模式那样得到所有的消息参数。OK，说到这儿，你是否对于推模式和拉模式有了一点了解呢？我把前面的例子修改为了拉模式，供大家参考，可以看到通知方法是没有任何参数的：
public
abstract
class
Stock
{ private List<IObserver> observers = new List<IObserver>(); private String _symbol; private double _price; public Stock(String symbol, double price) { this._symbol = symbol; this._price = price; } public void Update() { foreach (IObserver ob in observers) { ob.SendData(); } } public void AddObserver(IObserver observer) { observers.Add(observer); } public void RemoveObserver(IObserver observer) { observers.Remove(observer); } public String Symbol { get { return _symbol; } } public double Price { get { return _price; } }}
public
class
Microsoft : Stock
{ public Microsoft(String symbol, double price) : base(symbol, price) { }}
public
interface
IObserver
{ void SendData();}
public
class
Investor : IObserver
{ private string _name; private Stock _stock; public Investor(string name,Stock stock) { this._name = name; this._stock = stock; } public void SendData() { Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", _name, _stock.Symbol, _stock.Price); }}
class
Program
{ static void Main(string[] args) { Stock ms = new Microsoft("Microsoft", 120.00); ms.AddObserver(new Investor("Jom",ms)); ms.AddObserver(new Investor("TerryLee",ms)); ms.Update(); Console.ReadLine(); }}
当然拉模式也是有一些缺点的，主体对象和观察者之间的耦合加强了，但是这可以通过抽象的手段使这种耦合关系减到最小。[感谢idior的意见]
.NET中的Observer模式
在.NET中，相信大家对于事件和委托都已经不陌生了，这里就不具体多说了。利用事件和委托来实现Observer模式我认为更加的简单和优雅，也是一种更好的解决方案。因为在上面的示例中我们可以看到，虽然取消了直接耦合，但是又引入了不必要的约束（暂且这么说吧）。即那些子类必须都继承于主题父类，还有观察者接口等。网上有很多这方面的例子，上面的例子简单的用事件和委托实现如下，仅供大家参考：
class
Program
{ static void Main(string[] args) { Stock stock = new Stock("Microsoft", 120.00); Investor investor = new Investor("Jom"); stock.NotifyEvent += new NotifyEventHandler(investor.SendData); stock.Update(); Console.ReadLine(); }}
public
delegate
void
NotifyEventHandler(
object
sender);
public
class
Stock
{ public NotifyEventHandler NotifyEvent; private String _symbol; private double _price; public Stock(String symbol, double price) { this._symbol = symbol; this._price = price; } public void Update() { OnNotifyChange(); } public void OnNotifyChange() { if (NotifyEvent != null) { NotifyEvent(this); } } public String Symbol { get { return _symbol; } } public double Price { get { return _price; } }}
public
class
Investor
{ private string _name; public Investor(string name) { this._name = name; } public void SendData(object obj) { if (obj is Stock) { Stock stock = (Stock)obj; Console.WriteLine("Notified {0} of {1}'s " + "change to {2:C}", _name, stock.Symbol, stock.Price); } }}
效果及实现要点
1．使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
2．目标发送通知时，无需指定观察者，通知（可以携带通知信息作为参数）会自动传播。观察者自己决定是否需要订阅通知。目标对象对此一无所知。
3．在C#中的Event。委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象，委托是比抽象Observer接口更为松耦合的设计。
适用性
1．当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2．当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
3．当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
总结
通过Observer模式，把一对多对象之间的通知依赖关系的变得更为松散，大大地提高了程序的可维护性和可扩展性，也很好的符合了开放-封闭原则。
参考资料
Erich Gamma等，《设计模式：可复用面向对象软件的基础》，机械工业出版社
Robert C.Martin，《敏捷软件开发：原则、模式与实践》，清华大学出版社
阎宏，《Java与模式》，电子工业出版社
Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社
MSDN WebCast 《C#面向对象设计模式纵横谈(19)：Observer 观察者模式(行为型模式)》
更多设计模式文章请访问.NET设计模式系列
出处： http://terrylee.cnblogs.com
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
设计模式17：Observer Pattern (观察者模式)
Define:Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
一、 观察者（Observer）模式
观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作（Collaboration）。观察者模式是满足这一要求的各种设计方案中最重要的一种。
二、 观察者模式的结构
观察者模式的类图如下：
可以看出，在这个观察者模式的实现里有下面这些角色：
- 抽象主题（Subject）角色：主题角色把所有对观察考对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫做抽象被观察者（Observable）角色，一般用一个抽象类或者一个接口实现。
- 抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中，更新接口只包含一个方法（即Update()方法），这个方法叫做更新方法。
- 具体主题（ConcreteSubject）角色：将有关状态存入具体现察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色（Concrete Observable）。具体主题角色通常用一个具体子类实现。
- 具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。
从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做"针对抽象编程"。
三、 观察者模式的示意性源代码
- using System;
- using System.Collections.Generic;
- using System.Collections;
- using System.Linq;
- using System.Text;
-
- namespace Observer_Pattern
- {
- // "Subject"
- abstract class Subject
- {
- // Fields
- private ArrayList observers = new ArrayList();
-
- // Methods
- 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();
- }
- }
-
- // "ConcreteSubject"
- class ConcreteSubject : Subject
- {
- // Fields
- private string subjectState;
-
- // Properties
- public string SubjectState
- {
- get { return subjectState; }
- set { subjectState = value; }
- }
- }
-
- // "Observer"
- abstract class Observer
- {
- // Methods
- abstract public void Update();
- }
-
- // "ConcreteObserver"
- class ConcreteObserver : Observer
- {
- // Fields
- private string name;
- private string observerState;
- private ConcreteSubject subject;
-
- // Constructors
- public ConcreteObserver(ConcreteSubject subject,
- string name)
- {
- this.subject = subject;
- this.name = name;
- }
-
- // Methods
- override public void Update()
- {
- observerState = subject.SubjectState;
- Console.WriteLine("Observer {0}'s new state is {1}",
- name, observerState);
- }
-
- // Properties
- public ConcreteSubject Subject
- {
- get { return subject; }
- set { subject = value; }
- }
- }
-
- /**/
- /// <summary>
- /// Client test
- /// </summary>
- public class Client
- {
- public static void Main(string[] args)
- {
- // Configure Observer structure
- ConcreteSubject s = new ConcreteSubject();
- s.Attach(new ConcreteObserver(s, "1"));
- s.Attach(new ConcreteObserver(s, "2"));
- s.Attach(new ConcreteObserver(s, "3"));
-
- // Change subject and notify observers
- s.SubjectState = "ABC";
- s.Notify();
-
- Console.Read();
- }
- }
- }
四、 C#中的Delegate与Event
- using System;
- using System.Collections.Generic;
- using System.Collections;
- using System.Linq;
- using System.Text;
- namespace Observer_Pattern
- {
- // "Subject"
- abstract class Subject
- {
- // Fields
- private ArrayList observers = new ArrayList();
- // Methods
- 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();
- }
- }
- // "ConcreteSubject"
- class ConcreteSubject : Subject
- {
- // Fields
- private string subjectState;
- // Properties
- public string SubjectState
- {
- get { return subjectState; }
- set { subjectState = value; }
- }
- }
- // "Observer"
- abstract class Observer
- {
- // Methods
- abstract public void Update();
- }
- // "ConcreteObserver"
- class ConcreteObserver : Observer
- {
- // Fields
- private string name;
- private string observerState;
- private ConcreteSubject subject;
- // Constructors
- public ConcreteObserver(ConcreteSubject subject,
- string name)
- {
- this.subject = subject;
- this.name = name;
- }
- // Methods
- override public void Update()
- {
- observerState = subject.SubjectState;
- Console.WriteLine("Observer {0}'s new state is {1}",
- name, observerState);
- }
- // Properties
- public ConcreteSubject Subject
- {
- get { return subject; }
- set { subject = value; }
- }
- }
- /**/
- /// <summary>
- /// Client test
- /// </summary>
- public class Client
- {
- public static void Main(string[] args)
- {
- // Configure Observer structure
- ConcreteSubject s = new ConcreteSubject();
- s.Attach(new ConcreteObserver(s, "1"));
- s.Attach(new ConcreteObserver(s, "2"));
- s.Attach(new ConcreteObserver(s, "3"));
- // Change subject and notify observers
- s.SubjectState = "ABC";
- s.Notify();
- Console.Read();
- }
- }
- }
实际上在C#中实现Observer模式没有这么辛苦，.NET中提供了Delegate与Event机制，我们可以利用这种机制简化Observer模式。关于Delegate与Event的使用方法请参考相关文档。改进后的Observer模式实现如下：
- using System;
- using System.Collections.Generic;
- using System.Collections;
- using System.Linq;
- using System.Text;
- namespace Observer_Pattern
- {
- delegate void UpdateDelegate();
- //Subject
- class Subject
- {
- public event UpdateDelegate UpdateHandler;
- // Methods
- public void Attach(UpdateDelegate ud)
- {
- UpdateHandler += ud;
- }
- public void Detach(UpdateDelegate ud)
- {
- UpdateHandler -= ud;
- }
- public void Notify()
- {
- if (UpdateHandler != null) UpdateHandler();
- }
- }
- //ConcreteSubject
- class ConcreteSubject : Subject
- {
- // Fields
- private string subjectState;
- // Properties
- public string SubjectState
- {
- get { return subjectState; }
- set { subjectState = value; }
- }
- }
- // "ConcreteObserver"
- class ConcreteObserver
- {
- // Fields
- private string name;
- private string observerState;
- private ConcreteSubject subject;
- // Constructors
- public ConcreteObserver(ConcreteSubject subject,
- string name)
- {
- this.subject = subject;
- this.name = name;
- }
- // Methods
- public void Update()
- {
- observerState = subject.SubjectState;
- Console.WriteLine("Observer {0}'s new state is {1}",
- name, observerState);
- }
- // Properties
- public ConcreteSubject Subject
- {
- get { return subject; }
- set { subject = value; }
- }
- }
- // "ConcreteObserver"
- class AnotherObserver
- {
- // Methods
- public void Show()
- {
- Console.WriteLine("AnotherObserver got an Notification!");
- }
- }
- public class Client
- {
- public static void Main(string[] args)
- {
- ConcreteSubject s = new ConcreteSubject();
- ConcreteObserver o1 = new ConcreteObserver(s, "1");
- ConcreteObserver o2 = new ConcreteObserver(s, "2");
- AnotherObserver o3 = new AnotherObserver();
- s.Attach(new UpdateDelegate(o1.Update));
- s.Attach(new UpdateDelegate(o2.Update));
- s.Attach(new UpdateDelegate(o3.Show));
- s.SubjectState = "ABC";
- s.Notify();
- Console.WriteLine("--------------------------");
- s.Detach(new UpdateDelegate(o1.Update));
- s.SubjectState = "DEF";
- s.Notify();
- Console.Read();
- }
- }
- }
其中，关键的代码如下：
定义一个Delegate，用来规范函数结构。不管是ConcreteObserver类的Update方法还是AnotherObserver类的Show方法都符合该Delegate。这不象用Observer接口来规范必须使用Update方法那么严格。只要符合Delegate所指定的方法结构的方法都可以在后面被事件所处理。
定义一个事件，一旦触发，可以调用一组符合UpdateDelegate规范的方法。
{
UpdateHandler += ud;
}
订阅事件。只要是一个满足UpdateDelegate的方法，就可以进行订阅操作（如下所示）。
s.Attach( new UpdateDelegate(o2.Update));
s.Attach( new UpdateDelegate(o3.Show));
在Notify方法中：
{
if(UpdateHandler != null) UpdateHandler();
}
只要UpdateHandler != null（表示有订阅者），就可以触发事件（UpdateHandler()），所有的订阅者便会接到通知。
五、 一个实际应用观察者模式的例子
该例子演示了注册的投资者在股票市场发生变化时，可以自动得到通知。该例子仍然使用的是传统的Observer处理手段，至于如何转换成Delegate与Event留给读者自己考虑。
- using System;
- using System.Collections.Generic;
- using System.Collections;
- using System.Linq;
- using System.Text;
-
- namespace Observer_Pattern
- {
- abstract class Stock
- {
- // Fields
- protected string symbol;
- protected double price;
- private ArrayList investors = new ArrayList();
-
- // Constructor
- public Stock(string symbol, double price)
- {
- this.symbol = symbol;
- this.price = price;
- }
-
- // Methods
- public void Attach(Investor investor)
- {
- investors.Add(investor);
- }
-
- public void Detach(Investor investor)
- {
- investors.Remove(investor);
- }
-
- public void Notify()
- {
- foreach (Investor i in investors)
- i.Update(this);
- }
-
- // Properties
- public double Price
- {
- get { return price; }
- set
- {
- price = value;
- Notify();
- }
- }
-
- public string Symbol
- {
- get { return symbol; }
- set { symbol = value; }
- }
- }
-
- // "ConcreteSubject"
- class IBM : Stock
- {
- // Constructor
- public IBM(string symbol, double price)
- : base(symbol, price) { }
- }
-
- // "Observer"
- interface IInvestor
- {
- // Methods
- void Update(Stock stock);
- }
-
- // "ConcreteObserver"
- class Investor : IInvestor
- {
- // Fields
- private string name;
- private string observerState;
- private Stock stock;
-
- // Constructors
- public Investor(string name)
- {
- this.name = name;
- }
-
- // Methods
- public void Update(Stock stock)
- {
- Console.WriteLine("Notified investor {0} of {1}'s change to {2:C}",
- name, stock.Symbol, stock.Price);
- }
-
- // Properties
- public Stock Stock
- {
- get { return stock; }
- set { stock = value; }
- }
- }
-
- /**/
- /// <summary>
- /// ObserverApp test
- /// </summary>
- public class ObserverApp
- {
- public static void Main(string[] args)
- {
- // Create investors
- Investor s = new Investor("Sorros");
- Investor b = new Investor("Berkshire");
-
- // Create IBM stock and attach investors
- IBM ibm = new IBM("IBM", 120.00);
- ibm.Attach(s);
- ibm.Attach(b);
-
- // Change price, which notifies investors
- ibm.Price = 120.10;
- ibm.Price = 121.00;
- ibm.Price = 120.50;
- ibm.Price = 120.75;
-
- Console.Read();
- }
- }
- }
六、 观察者模式的优缺点
- using System;
- using System.Collections.Generic;
- using System.Collections;
- using System.Linq;
- using System.Text;
- namespace Observer_Pattern
- {
- abstract class Stock
- {
- // Fields
- protected string symbol;
- protected double price;
- private ArrayList investors = new ArrayList();
- // Constructor
- public Stock(string symbol, double price)
- {
- this.symbol = symbol;
- this.price = price;
- }
- // Methods
- public void Attach(Investor investor)
- {
- investors.Add(investor);
- }
- public void Detach(Investor investor)
- {
- investors.Remove(investor);
- }
- public void Notify()
- {
- foreach (Investor i in investors)
- i.Update(this);
- }
- // Properties
- public double Price
- {
- get { return price; }
- set
- {
- price = value;
- Notify();
- }
- }
- public string Symbol
- {
- get { return symbol; }
- set { symbol = value; }
- }
- }
- // "ConcreteSubject"
- class IBM : Stock
- {
- // Constructor
- public IBM(string symbol, double price)
- : base(symbol, price) { }
- }
- // "Observer"
- interface IInvestor
- {
- // Methods
- void Update(Stock stock);
- }
- // "ConcreteObserver"
- class Investor : IInvestor
- {
- // Fields
- private string name;
- private string observerState;
- private Stock stock;
- // Constructors
- public Investor(string name)
- {
- this.name = name;
- }
- // Methods
- public void Update(Stock stock)
- {
- Console.WriteLine("Notified investor {0} of {1}'s change to {2:C}",
- name, stock.Symbol, stock.Price);
- }
- // Properties
- public Stock Stock
- {
- get { return stock; }
- set { stock = value; }
- }
- }
- /**/
- /// <summary>
- /// ObserverApp test
- /// </summary>
- public class ObserverApp
- {
- public static void Main(string[] args)
- {
- // Create investors
- Investor s = new Investor("Sorros");
- Investor b = new Investor("Berkshire");
- // Create IBM stock and attach investors
- IBM ibm = new IBM("IBM", 120.00);
- ibm.Attach(s);
- ibm.Attach(b);
- // Change price, which notifies investors
- ibm.Price = 120.10;
- ibm.Price = 121.00;
- ibm.Price = 120.50;
- ibm.Price = 120.75;
- Console.Read();
- }
- }
- }
Observer模式的优点是实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰，并抽象了更新接口，使得可以有各种各样不同的表示层（观察者）。
但是其缺点是每个外观对象必须继承这个抽像出来的接口类，这样就造成了一些不方便，比如有一个别人写的外观对象，并没有继承该抽象类，或者接口不对，我们又希望不修改该类直接使用它。虽然可以再应用Adapter模式来一定程度上解决这个问题，但是会造成更加复杂烦琐的设计，增加出错几率。
观察者模式的效果有以下几个优点：
（1）观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体现察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。
（2）观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。
观察者模式有下面的一些缺点：
（1）如果一个被观察者对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
（2）如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察考模式时要特别注意这一点。
（3）如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。
（4）虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。
乐在其中设计模式(C#) - 观察者模式(Observer Pattern)
作者： webabcd
介绍
定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。
示例
有一个Message实体类，某些对象对它的操作有Insert()方法，当发生某些改变的时候，通知所有这些对象并执行Insert()方法。
MessageModel
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Observer
{ /// <summary> /// Message实体类 /// </summary> public class MessageModel { /// <summary> /// 构造函数 /// </summary> /// <param name="msg">Message内容</param> /// <param name="pt">Message发布时间</param> public MessageModel(string msg, DateTime pt) { this._message = msg; this._publishTime = pt; } private string _message; /// <summary> /// Message内容 /// </summary> public string Message { get { return _message; } set { _message = value; } } private DateTime _publishTime; /// <summary> /// Message发布时间 /// </summary> public DateTime PublishTime { get { return _publishTime; } set { _publishTime = value; } } }}
IMessage
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Observer
{ /// <summary> /// 操作Message的接口（Observer） /// </summary> public interface IMessage { /// <summary> /// 插入Message /// </summary> /// <param name="mm">Message实体对象</param> /// <returns></returns> string Insert(MessageModel mm); }}
SqlMessage
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Observer
{ /// <summary> /// Sql方式操作Message（ConcreteObserver） /// </summary> public class SqlMessage : IMessage { /// <summary> /// 插入Message /// </summary> /// <param name="mm">Message实体对象</param> /// <returns></returns> public string Insert(MessageModel mm) { return "sql方式：" + mm.Message + " " + mm.PublishTime.ToString(); } }}
XmlMessage
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Observer
{ /// <summary> /// Xml方式操作Message（ConcreteObserver） /// </summary> public class XmlMessage : IMessage { /// <summary> /// 插入Message /// </summary> /// <param name="mm">Message实体对象</param> /// <returns></returns> public string Insert(MessageModel mm) { return "xml方式：" + mm.Message + " " + mm.PublishTime.ToString(); } }}
AbstractMessageSubject
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Observer
{ /// <summary> /// 抽象Message主题（Subject） /// </summary> public abstract class AbstractMessageSubject { private MessageModel _messageModel; private List<IMessage> list = new List<IMessage>(); /// <summary> /// 构造函数 /// </summary> /// <param name="mm">Message实体对象</param> public AbstractMessageSubject(MessageModel mm) { this._messageModel = mm; } /// <summary> /// 添加一个实现IMessage接口的对象 /// </summary> /// <param name="m">实现IMessage接口的对象</param> public void Attach(IMessage m) { list.Add(m); } /// <summary> /// 移除一个实现IMessage接口的对象 /// </summary> /// <param name="m">实现IMessage接口的对象</param> public void Detach(IMessage m) { list.Remove(m); } /// <summary> /// 通知所有观察者 /// </summary> /// <returns></returns> public string Notify() { string s = ""; foreach (IMessage i in list) { s += i.Insert(_messageModel); s += "<br />"; } return s; } /// <summary> /// Message发布时间 /// </summary> public DateTime PublishTime { get { return _messageModel.PublishTime; } set { _messageModel.PublishTime = value; Notify(); } } }}
MessageSubject
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
Pattern.Observer
{ /// <summary> /// Message主题（ConcreteSubject） /// </summary> public class MessageSubject : AbstractMessageSubject { /// <summary> /// 构造函数 /// </summary> /// <param name="mm">Message实体对象</param> public MessageSubject(MessageModel mm) : base(mm) { } }}
Test
using
System;
using
System.Data;
using
System.Configuration;
using
System.Collections;
using
System.Web;
using
System.Web.Security;
using
System.Web.UI;
using
System.Web.UI.WebControls;
using
System.Web.UI.WebControls.WebParts;
using
System.Web.UI.HtmlControls;
using
Pattern.Observer;
public
partial
class
Observer : System.Web.UI.Page
{ protected void Page_Load(object sender, EventArgs e) { MessageSubject m = new MessageSubject(new MessageModel("插入Message", DateTime.Now)); SqlMessage sqlMessage = new SqlMessage(); XmlMessage xmlMessage = new XmlMessage(); m.Attach(sqlMessage); m.Attach(xmlMessage); // System.Threading.Thread.Sleep(1000); // 修改了PublishTime就会通知所有观察者 // m.PublishTime = DateTime.Now; Response.Write(m.Notify()); }}
运行结果
sql方式：插入Message 2007-5-26 9:38:18
xml方式：插入Message 2007-5-26 9:38:18
参考
http://www.dofactory.com/Patterns/PatternObserver.aspx
OK
[源码下载]