读书笔记12：观察者模式

1、概念

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象，这个主题的状态发生变化是就通知所有的观察者对象，是这些观察者自动更新自己。

2、角色

观察者(Observer)—观察者有一个更新自己状态的方法，当它观察的那个主题的装太发生了变化，主题会通知这些观察者，观察者接到通知后更新自己的状态。所以观察者有一个Update()方法。

主题(Subject)—主题包含多个观察者，就有ADD和REMOVE观察者的方法。该主题的状态改变了需要通知那些观察者，所以还有一个Notify()方法。

3、代码模型

模型类

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4.   
5. namespace ObserverPattern  
6. {  
7.     public class Subject  
8.     {  
9.         private List<Observer> observers = new List<Observer>();  
10.   
11.         public void AddObserver(Observer observer)  
12.         {  
13.             observers.Add(observer);  
14.         }  
15.    
16.         public void RemoveObserver(Observer observer)  
17.         {  
18.             observers.Remove(observer);  
19.         }  
20.         public void Notify()  
21.         {  
22.             foreach (Observer observer in observers)  
23.             {  
24.                 observer.Update();  
25.             }  
26.         }  
27.     }  
28.   
29.     public abstract class Observer  
30.     {  
31.         public abstract void Update();  
32.     }  
33.   
34.     public class SubstanceSubject : Subject  
35.     {  
36.         private string currentSubjectState;  
37.    
38.         public string CurrentSubjectState  
39.         {  
40.             get { return currentSubjectState; }  
41.             set { currentSubjectState = value; }  
42.         }  
43.     }  
44.     public class SubstanceObserver : Observer  
45.     {  
46.         private string observerName;  
47.   
48.         private object observerState;   
49.         private SubstanceSubject currentSubstanceSubject;  
50.   
51.         public SubstanceObserver(SubstanceSubject subject ,string name)  
52.         {  
53.             this.currentSubstanceSubject = subject;  
54.             this.observerName = name;  
55.   
56.         }  
57.    
58.         public override void Update()  
59.         {  
60.             observerState = currentSubstanceSubject.CurrentSubjectState;  
61.             Console.WriteLine("观察者 {0} 的状态是 {1}", observerName, observerState);  
62.         }  
63.   
64.         public SubstanceSubject CurrentSubstanceSubject  
65.         {  
66.             get { return currentSubstanceSubject; }  
67.             set { currentSubstanceSubject = value; }  
68.   
69.         }  
70.     }  
71. }  

调用

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4.   
5. namespace ObserverPattern  
6. {  
7.     class Program  
8.     {  
9.         static void Main(string[] args)  
10.         {  
11.             SubstanceSubject sub = new SubstanceSubject();  
12.             SubstanceObserver suo1 = new SubstanceObserver(sub,"甲");  
13.             SubstanceObserver suo2 = new SubstanceObserver(sub,"乙");  
14.             SubstanceObserver suo3 = new SubstanceObserver(sub,"丙");  
15.             sub.AddObserver(suo1);  
16.             sub.AddObserver(suo2);  
17.             sub.AddObserver(suo3);  
18.   
19.             sub.CurrentSubjectState = "闲着没事干";  
20.             sub.Notify();  
21.    
22.   
23.             Console.WriteLine();  
24.             Console.WriteLine("改变状态，当前主题的所有观察者的状态都要更新：");  
25.             Console.WriteLine();  
26.   
27.             sub.CurrentSubjectState = "忙得昏天黑地";  
28.             sub.Notify();  
29.             Console.ReadLine();  
30.         }  
31.     }  
32. }  

结果

 

观察者模式主要是用于某一处状态的改变需要让其他不同的地方知道的情况下。最常见的就是在做窗体项目中，窗体中的某个控件我们可以用+=给他添加系统自带的事件比如按钮，

this.button.Click += new System.EventHandler(执行的方法1);我们可以给这个Click事件加很多方法this.button.Click += new System.EventHandler(执行的方法2);这就是观察者模式的应用。同时我们可以写自己的事件MyEventHandler，则有

this.button.Click += new MyEventHandler (执行的方法3);

   当然，这是.net类库已经实现好了的，在我们的实际项目中，可以按照上述的模型使用。只需建立好两个角色，做好实现。就解决那种“一处变化多处响应”的需求了。