原文: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類行為的改變，而且這些操作都是發生在運行時的。

三、應用狀態者模式完善中介者模式方案

　　在上一篇博文中，我曾介紹到中介者模式存在的問題，詳細的問題描述可以參考上一篇博文。下面利用觀察者模式和狀態者模式來完善中介者模式，具體的實現代碼如下所示：

  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     }