概述
Observer模式，就是建立一种机制，使多个对象依赖于某个特定对象，当这个特定的对象改变时，能通知到依赖它的所有对象作出反应。
观察者模式：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。
设计
这里就有2个问题：一个是这个特定对象如何知道它要通知那些对象，二是如何通知？先来看第一问题：如何知道要通知那些对象？那么就需要对象在生成或需要被通知时，主动告诉这个特定的对象：我是你通知的对象。这个特定对象把它们都“记”起来，到时一个个通知。如何通知呢？就需要被通知的对象公布一个接口，这个特定对象调用这个接口，通知发生改变。但是如果有很多对象需要通知，每个对象各有一个接口，就会导致这个特定对象需要记住很多接口，特麻烦！好在它很聪明，让所有的对象统一接口，否则就不通知它。
实现
名称
Observer
结构
意图
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
适用性
- 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
- 当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
- 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
Code Example
1
// Observer
2
3// Intent: "Define a one-to-many dependency between objects so that when one
4// object changes state, all its dependents are notified and
5// updated automatically".
6
7// For further information, read "Design Patterns", p293, Gamma et al.,
8// Addison-Wesley, ISBN:0-201-63361-2
9
10
/* Notes:
11
* Often used for Document-View architectures, where a document stores
12 * data and one or more views renders the data.
13
*/
14
15namespace Observer_DesignPattern
16{
17 using System;
18 using System.Collections;
19
20 class Subject
21
{
22 private ArrayList list = new ArrayList();
23
24 private string strImportantSubjectData = "Initial";
25
26 public string ImportantSubjectData
27 {
28 get
29 {
30 return strImportantSubjectData;
31
}
32 set
33 {
34 strImportantSubjectData = value;
35 }
36 }
37
38 public void Attach(Observer o)
39 {
40 list.Add(o);
41 o.ObservedSubject = this;
42 }
43
44 public void Detach(Observer o)
45 {
46
47 }
48
49 public void Notify()
50 {
51 foreach (Observer o in list)
52 {
53 o.Update();
54 }
55 }
56 }
57
58 class ConcreteSubject : Subject
59 {
60 public void GetState()
61 {
62
63 }
64
65 public void SetState()
66 {
67
68 }
69 }
70
71 abstract class Observer
72 {
73 protected Subject s;
74 public Subject ObservedSubject
75 {
76 get
77 {
78 return s;
79 }
80 set
81 {
82 s = value;
83 }
84 }
85 abstract public void Update();
86 }
87
88 class ConcreteObserver : Observer
89 {
90 private string observerName;
91
92 public ConcreteObserver(string name)
93 {
94 observerName = name;
95 }
96
97 override public void Update()
98 {
99 Console.WriteLine("In Observer {0}: data from subject = {1}",
100 observerName, s.ImportantSubjectData);
101 }
102 }
103
104 /// <summary>
105 /// Summary description for Client.
106 /// </summary>
107 public class Client
108 {
109 public static int Main(string[] args)
110 {
111 // Set up everything
112 ConcreteSubject s = new ConcreteSubject();
113 ConcreteObserver o1 = new ConcreteObserver("first observer");
114 ConcreteObserver o2 = new ConcreteObserver("second observer");
115
116 s.Attach(o1);
117 s.Attach(o2);
118
119 // make changes to subject
120 s. ImportantSubjectData = "This is important subject data";
121
122 // Notify all observers
123 s.Notify();
124 return 0;
125 }
126 }
127}
128
- 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
- 当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
- 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
1// Observer
2
3// Intent: "Define a one-to-many dependency between objects so that when one
4// object changes state, all its dependents are notified and
5// updated automatically".
6
7// For further information, read "Design Patterns", p293, Gamma et al.,
8// Addison-Wesley, ISBN:0-201-63361-2
9
10/* Notes:
11 * Often used for Document-View architectures, where a document stores
12 * data and one or more views renders the data.
13 */
14
15namespace Observer_DesignPattern
16{
17 using System;
18 using System.Collections;
19
20 class Subject
21 {
22 private ArrayList list = new ArrayList();
23
24 private string strImportantSubjectData = "Initial";
25
26 public string ImportantSubjectData
27 {
28 get
29 {
30 return strImportantSubjectData;
31 }
32 set
33 {
34 strImportantSubjectData = value;
35 }
36 }
37
38 public void Attach(Observer o)
39 {
40 list.Add(o);
41 o.ObservedSubject = this;
42 }
43
44 public void Detach(Observer o)
45 {
46
47 }
48
49 public void Notify()
50 {
51 foreach (Observer o in list)
52 {
53 o.Update();
54 }
55 }
56 }
57
58 class ConcreteSubject : Subject
59 {
60 public void GetState()
61 {
62
63 }
64
65 public void SetState()
66 {
67
68 }
69 }
70
71 abstract class Observer
72 {
73 protected Subject s;
74 public Subject ObservedSubject
75 {
76 get
77 {
78 return s;
79 }
80 set
81 {
82 s = value;
83 }
84 }
85 abstract public void Update();
86 }
87
88 class ConcreteObserver : Observer
89 {
90 private string observerName;
91
92 public ConcreteObserver(string name)
93 {
94 observerName = name;
95 }
96
97 override public void Update()
98 {
99 Console.WriteLine("In Observer {0}: data from subject = {1}",
100 observerName, s.ImportantSubjectData);
101 }
102 }
103
104 /// <summary>
105 /// Summary description for Client.
106 /// </summary>
107 public class Client
108 {
109 public static int Main(string[] args)
110 {
111 // Set up everything
112 ConcreteSubject s = new ConcreteSubject();
113 ConcreteObserver o1 = new ConcreteObserver("first observer");
114 ConcreteObserver o2 = new ConcreteObserver("second observer");
115
116 s.Attach(o1);
117 s.Attach(o2);
118
119 // make changes to subject
120 s. ImportantSubjectData = "This is important subject data";
121
122 // Notify all observers
123 s.Notify();
124 return 0;
125 }
126 }
127}
128
// Observer2
3
// Intent: "Define a one-to-many dependency between objects so that when one 4
// object changes state, all its dependents are notified and 5
// updated automatically". 6
7
// For further information, read "Design Patterns", p293, Gamma et al.,8
// Addison-Wesley, ISBN:0-201-63361-29
10
/* Notes:
11
* Often used for Document-View architectures, where a document stores 12
* data and one or more views renders the data. 13
*/14
15
namespace Observer_DesignPattern16
{17
using System;18
using System.Collections;19
20
class Subject21
{22
private ArrayList list = new ArrayList();23
24
private string strImportantSubjectData = "Initial";25
26
public string ImportantSubjectData 27
{28
get 29
{30
return strImportantSubjectData;31
}32
set 33
{34
strImportantSubjectData = value;35
}36
}37
38
public void Attach(Observer o)39
{40
list.Add(o);41
o.ObservedSubject = this;42
}43
44
public void Detach(Observer o)45
{46
47
}48
49
public void Notify()50
{51
foreach (Observer o in list) 52
{53
o.Update();54
} 55
}56
}57
58
class ConcreteSubject : Subject59
{60
public void GetState()61
{62
63
}64
65
public void SetState()66
{67
68
} 69
}70
71
abstract class Observer 72
{73
protected Subject s;74
public Subject ObservedSubject 75
{76
get 77
{78
return s; 79
}80
set 81
{82
s = value;83
}84
} 85
abstract public void Update();86
}87
88
class ConcreteObserver : Observer 89
{90
private string observerName;91
92
public ConcreteObserver(string name)93
{94
observerName = name;95
}96
97
override public void Update()98
{99
Console.WriteLine("In Observer {0}: data from subject = {1}", 100
observerName, s.ImportantSubjectData);101
} 102
}103
104
/// <summary>105
/// Summary description for Client.106
/// </summary>107
public class Client108
{ 109
public static int Main(string[] args)110
{ 111
// Set up everything112
ConcreteSubject s = new ConcreteSubject();113
ConcreteObserver o1 = new ConcreteObserver("first observer");114
ConcreteObserver o2 = new ConcreteObserver("second observer");115
116
s.Attach(o1);117
s.Attach(o2);118
119
// make changes to subject120
s. ImportantSubjectData = "This is important subject data";121
122
// Notify all observers123
s.Notify(); 124
return 0;125
}126
}127
}128
UML图：
示例代码为：
1using System;
2using System.Collections ;
3
4namespace Example
5{
6 /// <summary>
7 /// 示例
8 /// </summary>
9 class Example
10 {
11 /// <summary>
12 /// 应用程序的主入口点。
13 /// </summary>
14 [STAThread]
15 static void Main(string[] args)
16 {
17 Observer o1 = new O1() ;
18 Observer o2 = new O2() ;
19
20 Subject s = new Subject() ;
21 s.Notify() ;
22 }
23 /// <summary>
24 /// 被观察的对象
25 /// </summary>
26 public class Subject
27 {
28 /// <summary>
29 /// 静态数组保存观察者
30 /// </summary>
31 private static ArrayList list = new ArrayList() ;
32 /// <summary>
33 /// 把观察者加入到数组中
34 /// </summary>
35 /// <param name="o">被加入的观察者</param>
36 public static void Attach( Observer o )
37
40 /// <summary>
41 /// 把观察者退出到数组中
42 /// </summary>
43 /// <param name="o">被退出的观察者</param>
44 public static void Detach( Observer o )
45
48 /// <summary>
49 /// 逐个通知发生改变
50 /// </summary>
51 public void Notify()
52
58 }
59 /// <summary>
60 /// 观察者
61 /// </summary>
62 public class Observer
63 {
64 public Observer()
65 {
66 Subject.Attach( this ) ;//在生成时加入观察者列
67 }
68 ~Observer()
69 {
70 Subject.Detach( this ) ;//在注销时退出观察者列
71 }
72 public virtual void Update() {}//当观察的对象改变时
73 }
74 public class O1 : Observer
75 {
76 public override void Update()
77 {
78 Console.WriteLine( "O1 Update Now!" ) ;
79 }
80 }
81 public class O2 : Observer
82 {
83 public override void Update()
84 {
85 Console.WriteLine( "O2 Update Now!" ) ;
86 }
87
88 }
89 }
90}
91
using System;2
using System.Collections ;3
4
namespace Example5
{6
/// <summary>7
/// 示例8
/// </summary>9
class Example10
{11
/// <summary>12
/// 应用程序的主入口点。13
/// </summary>14
[STAThread]15
static void Main(string[] args)16
{17
Observer o1 = new O1() ;18
Observer o2 = new O2() ;19
20
Subject s = new Subject() ;21
s.Notify() ;22
}23
/// <summary>24
/// 被观察的对象25
/// </summary>26
public class Subject27
{28
/// <summary>29
/// 静态数组保存观察者30
/// </summary>31
private static ArrayList list = new ArrayList() ;32
/// <summary>33
/// 把观察者加入到数组中34
/// </summary>35
/// <param name="o">被加入的观察者</param>36
public static void Attach( Observer o )37
40
/// <summary>41
/// 把观察者退出到数组中42
/// </summary>43
/// <param name="o">被退出的观察者</param>44
public static void Detach( Observer o )45
48
/// <summary>49
/// 逐个通知发生改变50
/// </summary>51
public void Notify()52
58
}59
/// <summary>60
/// 观察者61
/// </summary>62
public class Observer63
{64
public Observer()65
{66
Subject.Attach( this ) ;//在生成时加入观察者列67
}68
~Observer()69
{70
Subject.Detach( this ) ;//在注销时退出观察者列71
}72
public virtual void Update() {}//当观察的对象改变时73
}74
public class O1 : Observer75
{76
public override void Update()77
{78
Console.WriteLine( "O1 Update Now!" ) ;79
}80
}81
public class O2 : Observer 82
{83
public override void Update()84
{85
Console.WriteLine( "O2 Update Now!" ) ;86
}87
88
}89
}90
}91
一、 观察者（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;//Delegatedelegate void UpdateDelegate(); //Subjectclass 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(); }}//ConcreteSubjectclass 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）虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。
