# C#設計模式(19)——狀態者模式（State Pattern）
## 一、引言
在上一篇文章介紹到可以使用狀態者模式和觀察者模式來解決中介者模式存在的問題，在本文中將首先通過一個銀行賬戶的例子來解釋狀態者模式，通過這個例子使大家可以對狀態者模式有一個清楚的認識，接著，再使用狀態者模式來解決上一篇文章中提出的問題。
## 二、狀態者模式的介紹
每個對象都有其對應的狀態，而每個狀態又對應一些相應的行為，如果某個對象有多個狀態時，那么就會對應很多的行為。那么對這些狀態的判斷和根據狀態完成的行為，就會導致多重條件語句，并且如果添加一種新的狀態時，需要更改之前現有的代碼。這樣的設計顯然違背了開閉原則。狀態模式正是用來解決這樣的問題的。狀態模式將每種狀態對應的行為抽象出來成為單獨新的對象，這樣狀態的變化不再依賴于對象內部的行為。
## 2.1 狀態者模式的定義
上面對狀態模式做了一個簡單的介紹，這里給出狀態模式的定義。
狀態模式——允許一個對象在其內部狀態改變時自動改變其行為，對象看起來就像是改變了它的類。
## 2.2 狀態者模式的結構
既然狀態者模式是對已有對象的狀態進行抽象，則自然就有抽象狀態者類和具體狀態者類，而原來已有對象需要保存抽象狀態者類的引用，通過調用抽象狀態者的行為來改變已有對象的行為。經過上面的分析，狀態者模式的結構圖也就很容易理解了，具體結構圖如下圖示。
從上圖可知，狀態者模式涉及以下三個角色：
* Account類：維護一個State類的一個實例，該實例標識著當前對象的狀態。
* State類：抽象狀態類，定義了一個具體狀態類需要實現的行為約定。
* SilveStater、GoldState和RedState類：具體狀態類，實現抽象狀態類的每個行為。
## 2.3 狀態者模式的實現
下面，就以銀行賬戶的狀態來實現下狀態者模式。銀行賬戶根據余額可分為RedState、SilverState和GoldState。這些狀態分別代表透支賬號，新開賬戶和標準賬戶。賬號余額在【-100.0，0.0】范圍表示處于RedState狀態，賬號余額在【0.0 ， 1000.0】范圍表示處于SilverState，賬號在【1000.0， 100000.0】范圍表示處于GoldState狀態。下面以這樣的一個場景實現下狀態者模式，具體實現代碼如下所示：
```
1 namespace StatePatternSample
2 {
3 public class Account
4 {
5 public State State {get;set;}
6 public string Owner { get; set; }
7 public Account(string owner)
8 {
9 this.Owner = owner;
10 this.State = new SilverState(0.0, this);
11 }
12
13 public double Balance { get {return State.Balance; }} // 余額
14 // 存錢
15 public void Deposit(double amount)
16 {
17 State.Deposit(amount);
18 Console.WriteLine("存款金額為 {0:C}——", amount);
19 Console.WriteLine("賬戶余額為 =:{0:C}", this.Balance);
20 Console.WriteLine("賬戶狀態為: {0}", this.State.GetType().Name);
21 Console.WriteLine();
22 }
23
24 // 取錢
25 public void Withdraw(double amount)
26 {
27 State.Withdraw(amount);
28 Console.WriteLine("取款金額為 {0:C}——",amount);
29 Console.WriteLine("賬戶余額為 =:{0:C}", this.Balance);
30 Console.WriteLine("賬戶狀態為: {0}", this.State.GetType().Name);
31 Console.WriteLine();
32 }
33
34 // 獲得利息
35 public void PayInterest()
36 {
37 State.PayInterest();
38 Console.WriteLine("Interest Paid --- ");
39 Console.WriteLine("賬戶余額為 =:{0:C}", this.Balance);
40 Console.WriteLine("賬戶狀態為: {0}", this.State.GetType().Name);
41 Console.WriteLine();
42 }
43 }
44
45 // 抽象狀態類
46 public abstract class State
47 {
48 // Properties
49 public Account Account { get; set; }
50 public double Balance { get; set; } // 余額
51 public double Interest { get; set; } // 利率
52 public double LowerLimit { get; set; } // 下限
53 public double UpperLimit { get; set; } // 上限
54
55 public abstract void Deposit(double amount); // 存款
56 public abstract void Withdraw(double amount); // 取錢
57 public abstract void PayInterest(); // 獲得的利息
58 }
59
60 // Red State意味著Account透支了
61 public class RedState : State
62 {
63 public RedState(State state)
64 {
65 // Initialize
66 this.Balance = state.Balance;
67 this.Account = state.Account;
68 Interest = 0.00;
69 LowerLimit = -100.00;
70 UpperLimit = 0.00;
71 }
72
73 // 存款
74 public override void Deposit(double amount)
75 {
76 Balance += amount;
77 StateChangeCheck();
78 }
79 // 取錢
80 public override void Withdraw(double amount)
81 {
82 Console.WriteLine("沒有錢可以取了！");
83 }
84
85 public override void PayInterest()
86 {
87 // 沒有利息
88 }
89
90 private void StateChangeCheck()
91 {
92 if (Balance > UpperLimit)
93 {
94 Account.State = new SilverState(this);
95 }
96 }
97 }
98
99 // Silver State意味著沒有利息得
100 public class SilverState :State
101 {
102 public SilverState(State state)
103 : this(state.Balance, state.Account)
104 {
105 }
106
107 public SilverState(double balance, Account account)
108 {
109 this.Balance = balance;
110 this.Account = account;
111 Interest = 0.00;
112 LowerLimit = 0.00;
113 UpperLimit = 1000.00;
114 }
115
116 public override void Deposit(double amount)
117 {
118 Balance += amount;
119 StateChangeCheck();
120 }
121 public override void Withdraw(double amount)
122 {
123 Balance -= amount;
124 StateChangeCheck();
125 }
126
127 public override void PayInterest()
128 {
129 Balance += Interest * Balance;
130 StateChangeCheck();
131 }
132
133 private void StateChangeCheck()
134 {
135 if (Balance < LowerLimit)
136 {
137 Account.State = new RedState(this);
138 }
139 else if (Balance > UpperLimit)
140 {
141 Account.State = new GoldState(this);
142 }
143 }
144 }
145
146 // Gold State意味著有利息狀態
147 public class GoldState : State
148 {
149 public GoldState(State state)
150 {
151 this.Balance = state.Balance;
152 this.Account = state.Account;
153 Interest = 0.05;
154 LowerLimit = 1000.00;
155 UpperLimit = 1000000.00;
156 }
157 // 存錢
158 public override void Deposit(double amount)
159 {
160 Balance += amount;
161 StateChangeCheck();
162 }
163 // 取錢
164 public override void Withdraw(double amount)
165 {
166 Balance -= amount;
167 StateChangeCheck();
168 }
169 public override void PayInterest()
170 {
171 Balance += Interest * Balance;
172 StateChangeCheck();
173 }
174
175 private void StateChangeCheck()
176 {
177 if (Balance < 0.0)
178 {
179 Account.State = new RedState(this);
180 }
181 else if (Balance < LowerLimit)
182 {
183 Account.State = new SilverState(this);
184 }
185 }
186 }
187
188 class App
189 {
190 static void Main(string[] args)
191 {
192 // 開一個新的賬戶
193 Account account = new Account("Learning Hard");
194
195 // 進行交易
196 // 存錢
197 account.Deposit(1000.0);
198 account.Deposit(200.0);
199 account.Deposit(600.0);
200
201 // 付利息
202 account.PayInterest();
203
204 // 取錢
205 account.Withdraw(2000.00);
206 account.Withdraw(500.00);
207
208 // 等待用戶輸入
209 Console.ReadKey();
210 }
211 }
212 }
```
上面代碼的運行結果如下圖所示：
從上圖可以發現，進行存取款交易，會影響到Account內部的狀態，由于狀態的改變，從而影響到Account類行為的改變，而且這些操作都是發生在運行時的。
## 三、應用狀態者模式完善中介者模式方案
在上一篇博文中，我曾介紹到中介者模式存在的問題，詳細的問題描述可以參考[上一篇博文](http://www.cnblogs.com/zhili/p/MediatorPattern.html)。下面利用觀察者模式和狀態者模式來完善中介者模式，具體的實現代碼如下所示：
```
1 // 抽象牌友類
2 public abstract class AbstractCardPartner
3 {
4 public int MoneyCount { get; set; }
5
6 public AbstractCardPartner()
7 {
8 MoneyCount = 0;
9 }
10
11 public abstract void ChangeCount(int Count, AbstractMediator mediator);
12 }
13
14 // 牌友A類
15 public class ParterA : AbstractCardPartner
16 {
17 // 依賴與抽象中介者對象
18 public override void ChangeCount(int Count, AbstractMediator mediator)
19 {
20 mediator.ChangeCount(Count);
21 }
22 }
23
24 // 牌友B類
25 public class ParterB : AbstractCardPartner
26 {
27 // 依賴與抽象中介者對象
28 public override void ChangeCount(int Count, AbstractMediator mediator)
29 {
30 mediator.ChangeCount(Count);
31 }
32 }
33
34 // 抽象狀態類
35 public abstract class State
36 {
37 protected AbstractMediator meditor;
38 public abstract void ChangeCount(int count);
39 }
40
41 // A贏狀態類
42 public class AWinState : State
43 {
44 public AWinState(AbstractMediator concretemediator)
45 {
46 this.meditor = concretemediator;
47 }
48
49 public override void ChangeCount(int count)
50 {
51 foreach (AbstractCardPartner p in meditor.list)
52 {
53 ParterA a = p as ParterA;
54 //
55 if (a != null)
56 {
57 a.MoneyCount += count;
58 }
59 else
60 {
61 p.MoneyCount -= count;
62 }
63 }
64 }
65 }
66
67 // B贏狀態類
68 public class BWinState : State
69 {
70 public BWinState(AbstractMediator concretemediator)
71 {
72 this.meditor = concretemediator;
73 }
74
75 public override void ChangeCount(int count)
76 {
77 foreach (AbstractCardPartner p in meditor.list)
78 {
79 ParterB b = p as ParterB;
80 // 如果集合對象中時B對象，則對B的錢添加
81 if (b != null)
82 {
83 b.MoneyCount += count;
84 }
85 else
86 {
87 p.MoneyCount -= count;
88 }
89 }
90 }
91 }
92
93 // 初始化狀態類
94 public class InitState : State
95 {
96 public InitState()
97 {
98 Console.WriteLine("游戲才剛剛開始,暫時還有玩家勝出");
99 }
100
101 public override void ChangeCount(int count)
102 {
103 //
104 return;
105 }
106 }
107
108 // 抽象中介者類
109 public abstract class AbstractMediator
110 {
111 public List<AbstractCardPartner> list = new List<AbstractCardPartner>();
112
113 public State State { get; set; }
114
115 public AbstractMediator(State state)
116 {
117 this.State = state;
118 }
119
120 public void Enter(AbstractCardPartner partner)
121 {
122 list.Add(partner);
123 }
124
125 public void Exit(AbstractCardPartner partner)
126 {
127 list.Remove(partner);
128 }
129
130 public void ChangeCount(int count)
131 {
132 State.ChangeCount(count);
133 }
134 }
135
136 // 具體中介者類
137 public class MediatorPater : AbstractMediator
138 {
139 public MediatorPater(State initState)
140 : base(initState)
141 { }
142 }
143
144 class Program
145 {
146 static void Main(string[] args)
147 {
148 AbstractCardPartner A = new ParterA();
149 AbstractCardPartner B = new ParterB();
150 // 初始錢
151 A.MoneyCount = 20;
152 B.MoneyCount = 20;
153
154 AbstractMediator mediator = new MediatorPater(new InitState());
155
156 // A,B玩家進入平臺進行游戲
157 mediator.Enter(A);
158 mediator.Enter(B);
159
160 // A贏了
161 mediator.State = new AWinState(mediator);
162 mediator.ChangeCount(5);
163 Console.WriteLine("A 現在的錢是：{0}", A.MoneyCount);// 應該是25
164 Console.WriteLine("B 現在的錢是：{0}", B.MoneyCount); // 應該是15
165
166 // B 贏了
167 mediator.State = new BWinState(mediator);
168 mediator.ChangeCount(10);
169 Console.WriteLine("A 現在的錢是：{0}", A.MoneyCount);// 應該是25
170 Console.WriteLine("B 現在的錢是：{0}", B.MoneyCount); // 應該是15
171 Console.Read();
172 }
173 }
```
## 四、狀態者模式的應用場景
在以下情況下可以考慮使用狀態者模式。
* 當一個對象狀態轉換的條件表達式過于復雜時可以使用狀態者模式。把狀態的判斷邏輯轉移到表示不同狀態的一系列類中，可以把復雜的判斷邏輯簡單化。
* 當一個對象行為取決于它的狀態，并且它需要在運行時刻根據狀態改變它的行為時，就可以考慮使用狀態者模式。
## 五、狀態者模式的優缺點
狀態者模式的主要優點是：
* 將狀態判斷邏輯每個狀態類里面，可以簡化判斷的邏輯。
* 當有新的狀態出現時，可以通過添加新的狀態類來進行擴展，擴展性好。
狀態者模式的主要缺點是：
* 如果狀態過多的話，會導致有非常多的狀態類，加大了開銷。
## 六、總結
狀態者模式是對對象狀態的抽象，從而把對象中對狀態復雜的判斷邏輯已到各個狀態類里面，從而簡化邏輯判斷。在下一篇文章將分享我對策略模式的理解。
- C# 基礎知識系列
- C# 基礎知識系列 專題一：深入解析委托——C#中為什么要引入委托
- C# 基礎知識系列 專題二：委托的本質論
- C# 基礎知識系列 專題三：如何用委托包裝多個方法——委托鏈
- C# 基礎知識系列 專題四：事件揭秘
- C# 基礎知識系列 專題五：當點擊按鈕時觸發Click事件背后發生的事情
- C# 基礎知識系列 專題六:泛型基礎篇——為什么引入泛型
- C# 基礎知識系列 專題七: 泛型深入理解(一)
- C# 基礎知識系列 專題八: 深入理解泛型(二)
- C# 基礎知識系列 專題九: 深入理解泛型可變性
- C#基礎知識系列 專題十:全面解析可空類型
- C# 基礎知識系列 專題十一:匿名方法解析
- C#基礎知識系列 專題十二:迭代器
- C#基礎知識 專題十三：全面解析對象集合初始化器、匿名類型和隱式類型
- C# 基礎知識系列 專題十四：深入理解Lambda表達式
- C# 基礎知識系列 專題十五：全面解析擴展方法
- C# 基礎知識系列 專題十六：Linq介紹
- C#基礎知識系列 專題十七：深入理解動態類型
- 你必須知道的異步編程 C# 5.0 新特性——Async和Await使異步編程更簡單
- 全面解析C#中參數傳遞
- C#基礎知識系列 全面解析C#中靜態與非靜態
- C# 基礎知識系列 C#中易混淆的知識點
- C#進階系列
- C#進階系列 專題一：深入解析深拷貝和淺拷貝
- C#進階系列 專題二：你知道Dictionary查找速度為什么快嗎？
- C# 開發技巧系列
- C# 開發技巧系列 使用C#操作Word和Excel程序
- C# 開發技巧系列 使用C#操作幻燈片
- C# 開發技巧系列 如何動態設置屏幕分辨率
- C# 開發技巧系列 C#如何實現圖片查看器
- C# 開發技巧 如何防止程序多次運行
- C# 開發技巧 實現屬于自己的截圖工具
- C# 開發技巧 如何使不符合要求的元素等于離它最近的一個元素
- C# 線程處理系列
- C# 線程處理系列 專題一：線程基礎
- C# 線程處理系列 專題二：線程池中的工作者線程
- C# 線程處理系列 專題三：線程池中的I/O線程
- C# 線程處理系列 專題四：線程同步
- C# 線程處理系列 專題五：線程同步——事件構造
- C# 線程處理系列 專題六：線程同步——信號量和互斥體
- C# 多線程處理系列專題七——對多線程的補充
- C#網絡編程系列
- C# 網絡編程系列 專題一：網絡協議簡介
- C# 網絡編程系列 專題二：HTTP協議詳解
- C# 網絡編程系列 專題三：自定義Web服務器
- C# 網絡編程系列 專題四：自定義Web瀏覽器
- C# 網絡編程系列 專題五：TCP編程
- C# 網絡編程系列 專題六：UDP編程
- C# 網絡編程系列 專題七：UDP編程補充——UDP廣播程序的實現
- C# 網絡編程系列 專題八：P2P編程
- C# 網絡編程系列 專題九：實現類似QQ的即時通信程序
- C# 網絡編程系列 專題十：實現簡單的郵件收發器
- C# 網絡編程系列 專題十一：實現一個基于FTP協議的程序——文件上傳下載器
- C# 網絡編程系列 專題十二：實現一個簡單的FTP服務器
- C# 互操作性入門系列
- C# 互操作性入門系列(一)：C#中互操作性介紹
- C# 互操作性入門系列(二)：使用平臺調用調用Win32 函數
- C# 互操作性入門系列(三)：平臺調用中的數據封送處理
- C# 互操作性入門系列(四)：在C# 中調用COM組件
- CLR
- 談談: String 和StringBuilder區別和選擇
- 談談：程序集加載和反射
- 利用反射獲得委托和事件以及創建委托實例和添加事件處理程序
- 談談：.Net中的序列化和反序列化
- C#設計模式
- UML類圖符號 各種關系說明以及舉例
- C#設計模式(1)——單例模式
- C#設計模式(2)——簡單工廠模式
- C#設計模式(3)——工廠方法模式
- C#設計模式(4)——抽象工廠模式
- C#設計模式(5)——建造者模式（Builder Pattern）
- C#設計模式(6)——原型模式（Prototype Pattern）
- C#設計模式(7)——適配器模式（Adapter Pattern）
- C#設計模式(8)——橋接模式（Bridge Pattern）
- C#設計模式(9)——裝飾者模式（Decorator Pattern）
- C#設計模式(10)——組合模式（Composite Pattern）
- C#設計模式(11)——外觀模式（Facade Pattern）
- C#設計模式(12)——享元模式（Flyweight Pattern）
- C#設計模式(13)——代理模式（Proxy Pattern）
- C#設計模式(14)——模板方法模式（Template Method）
- C#設計模式(15)——命令模式（Command Pattern）
- C#設計模式(16)——迭代器模式（Iterator Pattern）
- C#設計模式(17)——觀察者模式（Observer Pattern）
- C#設計模式(18)——中介者模式（Mediator Pattern）
- C#設計模式(19)——狀態者模式（State Pattern）
- C#設計模式(20)——策略者模式（Stragety Pattern）
- C#設計模式(21)——責任鏈模式
- C#設計模式(22)——訪問者模式（Vistor Pattern）
- C#設計模式(23)——備忘錄模式（Memento Pattern）
- C#設計模式總結
- WPF快速入門系列
- WPF快速入門系列(1)——WPF布局概覽
- WPF快速入門系列(2)——深入解析依賴屬性
- WPF快速入門系列(3)——深入解析WPF事件機制
- WPF快速入門系列(4)——深入解析WPF綁定
- WPF快速入門系列(5)——深入解析WPF命令
- WPF快速入門系列(6)——WPF資源和樣式
- WPF快速入門系列(7)——深入解析WPF模板
- WPF快速入門系列(8)——MVVM快速入門
- WPF快速入門系列(9)——WPF任務管理工具實現
- ASP.NET 開發
- ASP.NET 開發必備知識點(1)：如何讓Asp.net網站運行在自定義的Web服務器上
- ASP.NET 開發必備知識點(2)：那些年追過的ASP.NET權限管理
- ASP.NET中實現回調
- 跟我一起學WCF
- 跟我一起學WCF(1)——MSMQ消息隊列
- 跟我一起學WCF(2)——利用.NET Remoting技術開發分布式應用
- 跟我一起學WCF(3)——利用Web Services開發分布式應用
- 跟我一起學WCF(3)——利用Web Services開發分布式應用
- 跟我一起學WCF(4)——第一個WCF程序
- 跟我一起學WCF(5)——深入解析服務契約 上篇
- 跟我一起學WCF(6)——深入解析服務契約 下篇
- 跟我一起學WCF(7)——WCF數據契約與序列化詳解
- 跟我一起學WCF(8)——WCF中Session、實例管理詳解
- 跟我一起學WCF(9)——WCF回調操作的實現
- 跟我一起學WCF(10)——WCF中事務處理
- 跟我一起學WCF(11)——WCF中隊列服務詳解
- 跟我一起學WCF(12)——WCF中Rest服務入門
- 跟我一起學WCF(13)——WCF系列總結
- .NET領域驅動設計實戰系列
- .NET領域驅動設計實戰系列 專題一：前期準備之EF CodeFirst
- .NET領域驅動設計實戰系列 專題二：結合領域驅動設計的面向服務架構來搭建網上書店
- .NET領域驅動設計實戰系列 專題三：前期準備之規約模式(Specification Pattern)
- .NET領域驅動設計實戰系列 專題四：前期準備之工作單元模式(Unit Of Work)
- .NET領域驅動設計實戰系列 專題五：網上書店規約模式、工作單元模式的引入以及購物車的實現
- .NET領域驅動設計實戰系列 專題六：DDD實踐案例：網上書店訂單功能的實現
- .NET領域驅動設計實戰系列 專題七：DDD實踐案例：引入事件驅動與中間件機制來實現后臺管理功能
- .NET領域驅動設計實戰系列 專題八：DDD案例：網上書店分布式消息隊列和分布式緩存的實現
- .NET領域驅動設計實戰系列 專題九：DDD案例：網上書店AOP和站點地圖的實現
- .NET領域驅動設計實戰系列 專題十：DDD擴展內容：全面剖析CQRS模式實現
- .NET領域驅動設計實戰系列 專題十一：.NET 領域驅動設計實戰系列總結