# 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 领域驱动设计实战系列总结