Title:《设计模式-策略模式》
Author:Hugu
StartedDate:September 28th. 2019.
FinishedDate:September 28th. 2019.
定义理解
策略模式时一种行为型模式,主要用于需要使用不同的算法来处理不同的数据(对象)时。策略模式是一种定义一系列算法的的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,它可以以相同的方式调用所有的算法,减少各种算法类与使用算法类之间的耦合,即在运行时选择算法。
定义算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化,不会影响到使用算法的客户 。
角色与职责
-
抽象策略角色(Strategy):策略类,通常由一个接口或者抽象类来实现
定义一个公共接口,各种不同的算法以不同的方式实现这个接口,Context使用这个接口调用不同的算法,一般用接口或抽象类来实现。
-
具体策略角色(ConcreteStrategy):包装了相关的算法和行为
实现Strategy定义的接口,提供具体的算法实现。
-
环境角色(Context):持有一个策略类的引用最终给客户端调用
- 需要使用ConcreteStrategy提供的算法
- 内部维护一个Strategy的实例
- 负责动态设置运行时Strategy具体的实现算法
- 负责跟Strategy之间的交互和数据传递
实现步骤
- 识别客户端可能需要的各种算法(即功能)(抽象策略角色)
- 在接口中指定该算法的签名(原型)(具体策略角色)
- 在派生类中提供可选择的实现细节(环境角色)
- 将客户端的算法和接口耦合
代码示例
代码结构图:
抽象策略角色:
CashSuper类:
namespace 商场管理软件
{
//算法的公共接口
abstract class CashSuper
{
//抽象出来的接口方法
public abstract double acceptCash(double money);
}
}
具体策略角色:
CashNormal类:
namespace 商场管理软件
{
//不折扣算法
class CashNormal : CashSuper
{
public override double acceptCash(double money)
{
return money;
}
}
}
CashRebate类:
namespace 商场管理软件
{
//折扣算法
class CashRebate : CashSuper
{
// 几折(默认为1折)
private double moneyRebate = 1d;
#region 带参构造函数-设置打折力度
/// <summary>
/// 带参构造函数-设置打折力度
/// </summary>
/// <param name="moneyRebate">几折</param>
public CashRebate(string moneyRebate)
{
this.moneyRebate = double.Parse(moneyRebate);
}
#endregion
#region 重写acceptCash方法
/// <summary>
/// 重写acceptCash方法
/// </summary>
/// <param name="money">原始钱数</param>
/// <returns>返回折后钱数</returns>
public override double acceptCash(double money)
{
return money * moneyRebate;
}
#endregion
}
}
CashReturn类:
using System;
namespace 商场管理软件
{
//返利算法
class CashReturn : CashSuper
{
// 金额限度
private double moneyCondition = 0.0d;
// 返还力度
private double moneyReturn = 0.0d;
#region 构造函数-设置金额限度和返还力度
/// <summary>
/// 构造函数-设置金额限度和返还力度
/// </summary>
/// <param name="moneyCondition">金额限度</param>
/// <param name="moneyReturn">返还力度</param>
public CashReturn(string moneyCondition, string moneyReturn)
{
this.moneyCondition = double.Parse(moneyCondition);
this.moneyReturn = double.Parse(moneyReturn);
}
#endregion
#region 重构acceptCash方法
/// <summary>
/// 重构acceptCash方法
/// </summary>
/// <param name="money">原始金额</param>
/// <returns>返回实际应付金额</returns>
public override double acceptCash(double money)
{
double result = money;
if (money >= moneyCondition)
result = money - Math.Floor(money / moneyCondition) * moneyReturn;
return result;
}
#endregion
}
}
环境角色:
CashContext类:
namespace 商场管理软件
{
//收费策略Context
class CashContext
{
//声明一个现金收费父类对象
private CashSuper cs;
//设置策略行为,参数为具体的现金收费子类(正常,打折或返利)
public CashContext(CashSuper csuper)
{
this.cs = csuper;
}
//得到现金促销计算结果(利用了多态机制,不同的策略行为导致不同的结果)
public double GetResult(double money)
{
return cs.acceptCash(money);
}
}
}
测试类:
测试界面:
测试类代码:
using System;
using System.Windows.Forms;
namespace 商场管理软件
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
double total = 0.0d;//用于总计
private void btnOk_Click(object sender, EventArgs e)
{
CashContext cc = null;
switch (cbxType.SelectedItem.ToString())
{
//直接传策略对象参数进行上下文对象的创建
case "正常收费":
cc = new CashContext(new CashNormal());
break;
case "满300返100":
cc = new CashContext(new CashReturn("300", "100"));
break;
case "打8折":
cc = new CashContext(new CashRebate("0.8"));
break;
}
double totalPrices = 0d;
//计算
totalPrices = cc.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
//显示结果
lbxList.Items.Add("单价:" + txtPrice.Text + " 数量:" + txtNum.Text + " " + cbxType.SelectedItem + " 合计:" + totalPrices.ToString());
lblResult.Text = total.ToString();
}
private void btnClear_Click(object sender, EventArgs e)
{
total = 0d;
txtPrice.Text = "0.00";
txtNum.Text = "1";
lbxList.Items.Clear();
lblResult.Text = "0.00";
}
}
}
测试结果:
优缺点
优点:
- 策略模式提供了管理相关算法族的办法。
- 策略模式提供了可以替换继承关系的办法。
- 使用策略模式可以避免使用多重条件转移语句。
缺点:
- 客户端必须知道所有的策略类,并且自行决定使用哪一个策略类
- 策略模式造成很多的策略类,每一个具体的策略类都会产生一个新类
使用场景
- 多个类只区别在表现行为不同,可以使用Strategy模式,在运行时动态选择具体要执行的行为;
- 需要在不同情况下使用不同的策略(算法),或者策略还可能在未来用其他方式来实现;
- 对客户隐藏具体的策略(算法)的实现细节,彼此完全独立。
算法改进
策略与简单工厂集合
改造后的环境类:(CashContext.cs)
namespace 商场管理软件
{
//现金收取工厂
class CashContext
{
CashSuper cs = null;
//根据条件返回相应的对象
public CashContext(string type)
{
switch (type)
{
case "正常收费":
CashNormal cs0 = new CashNormal();
cs = cs0;
break;
case "满300返100":
CashReturn cr1 = new CashReturn("300", "100");
cs = cr1;
break;
case "打8折":
CashRebate cr2 = new CashRebate("0.8");
cs = cr2;
break;
}
}
public double GetResult(double money)
{
return cs.acceptCash(money);
}
}
}
客户端测试代码:
using System;
using System.Windows.Forms;
namespace 商场管理软件
{
//策略对象的的创建在上下文类中完成,即策略对象的创建是对用户保密的
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
//客户端窗体程序(主要部分)
double total = 0.0d;
private void btnOk_Click(object sender, EventArgs e)
{
//利用简单工厂模式根据下拉选择框,生成相应的对象
CashContext csuper = new CashContext(cbxType.SelectedItem.ToString());
double totalPrices = 0d;
//通过多态,可以得到收取费用的结果
totalPrices = csuper.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
//展示计价结果
lbxList.Items.Add("单价:" + txtPrice.Text + " 数量:" + txtNum.Text + " "
+ cbxType.SelectedItem + " 合计:" + totalPrices.ToString());
lblResult.Text = total.ToString();
}
private void btnClear_Click(object sender, EventArgs e)
{
total = 0d;
txtPrice.Text = "0.00";
txtNum.Text = "0";
lbxList.Items.Clear();
lblResult.Text = "0.00";
}
}
}
注:
- 策略模式客户端需要认识CashSuper类、CashNormal类、CashReturn类、CashRebate类、CashContext类;
- 简单工厂模式客户端需要认识CashSuper类、工厂类;
- 策略与简单工厂集合之后,客户端只需要认识一个CashContext类即可,耦合度更加低。
策略 + 反射
改造后的环境类:(CashContext.cs)
namespace 商场管理软件
{
class CashContext
{
private CashSuper cs;
//设置上下文中的策略实例对象
public void setBehavior(CashSuper csuper)
{
this.cs = csuper;
}
public double GetResult(double money)
{
return cs.acceptCash(money);
}
}
}
客户端测试代码:
/**********************************
*
* 程序说明:使用反射 + 策略模式 来实现
*
* 反射:下拉列表中的文件数据直接从配置.xml文件中获取,即在程序运行时程序才知道下拉框中会有什么内容
* 策略:使用能统一调用所有策略对象的上下文对象
*
*
*/
using System;
using System.Data;
using System.Windows.Forms;
using System.Reflection;
namespace 商场管理软件
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
DataSet ds;//用于存放配置文件信息
double total = 0.0d;//用于总计
/// <summary>
/// 在程序加载时,读取指定文件中的所有内容
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Form1_Load(object sender, EventArgs e)
{
//读配置文件 --在程序运行的路径下
ds = new DataSet();
ds.ReadXml(Application.StartupPath + "\\CashAcceptType.xml");
//将读取到的记录绑定到下拉列表框中
foreach (DataRowView dr in ds.Tables[0].DefaultView)
{
cbxType.Items.Add(dr["name"].ToString());
}
cbxType.SelectedIndex = 0;
}
private void btnOk_Click(object sender, EventArgs e)
{
//实例化一个上下文对象
CashContext cc = new CashContext();
//根据用户的选项,查询用户选择项的相关行
DataRow dr = ((DataRow[])ds.Tables[0].Select("name='" + cbxType.SelectedItem.ToString()+"'"))[0];
//声明一个参数的对象数组
object[] args =null;
//若有参数,则将其分割成字符串数组,用于实例化时所用的参数
if (dr["para"].ToString() != "")
args = dr["para"].ToString().Split(',');
//通过反射实例化出相应的算法对象
cc.setBehavior((CashSuper)Assembly.Load("商场管理软件").CreateInstance("商场管理软件." + dr["class"].ToString(), false, BindingFlags.Default, null, args, null, null));
double totalPrices = 0d;
totalPrices = cc.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
lbxList.Items.Add("单价:" + txtPrice.Text + " 数量:" + txtNum.Text + " "+cbxType.SelectedItem+ " 合计:" + totalPrices.ToString());
lblResult.Text = total.ToString();
}
private void btnClear_Click(object sender, EventArgs e)
{
total = 0d;
txtPrice.Text = "0.00";
txtNum.Text = "1";
lbxList.Items.Clear();
lblResult.Text = "0.00";
}
}
}
CashAcceptType.xml:
<?xml version="1.0" encoding="utf-8" ?>
<CashAcceptType>
<type>
<name>正常收费</name>
<class>CashNormal</class>
<para></para>
</type>
<type>
<name>满300返100</name>
<class>CashReturn</class>
<para>300,100</para>
</type>
<type>
<name>满200返50</name>
<class>CashReturn</class>
<para>200,50</para>
</type>
<type>
<name>打8折</name>
<class>CashRebate</class>
<para>0.8</para>
</type>
<type>
<name>打7折</name>
<class>CashRebate</class>
<para>0.7</para>
</type>
</CashAcceptType>
测试结果:
策略模式与简单工厂模式的区别
从组成对象来说:
- 简单工厂模式:抽象商品角色、具体商品角色、简单工厂角色
- 策略模式:抽象策略角色、具体策略角色、上下文角色(环境角色)
从角色之间得关系来说:
- 抽象策略角色与上下文角色的关系是聚合关系
- 抽象商品角色与简单工厂角色之间是依赖关系
附录
参考资料
- 《大话设计模式》
- 《设计模式精解及面试攻略》
策略与简单工厂集合完整源码
CashContext.cs:
namespace 商场管理软件
{
//现金收取工厂
class CashContext
{
CashSuper cs = null;
//根据条件返回相应的对象
public CashContext(string type)
{
switch (type)
{
case "正常收费":
CashNormal cs0 = new CashNormal();
cs = cs0;
break;
case "满300返100":
CashReturn cr1 = new CashReturn("300", "100");
cs = cr1;
break;
case "打8折":
CashRebate cr2 = new CashRebate("0.8");
cs = cr2;
break;
}
}
public double GetResult(double money)
{
return cs.acceptCash(money);
}
}
}
CashNormal.cs:
namespace 商场管理软件
{
//正常收费,继承CashSuper
class CashNormal : CashSuper
{
public override double acceptCash(double money)
{
return money;
}
}
}
CashRebate.cs:
namespace 商场管理软件
{
//打折收费,继承CashSuper
class CashRebate : CashSuper
{
private double moneyRebate = 1d;
//初始化时,必需要输入折扣率,如八折,就是0.8
public CashRebate(string moneyRebate)
{
this.moneyRebate = double.Parse(moneyRebate);
}
public override double acceptCash(double money)
{
return money * moneyRebate;
}
}
}
CashReturn.cs:
using System;
namespace 商场管理软件
{
//返利收费,继承CashSuper
class CashReturn : CashSuper
{
private double moneyCondition = 0.0d;
private double moneyReturn = 0.0d;
//初始化时必须要输入返利条件和返利值,比如满300返100,则moneyCondition为300,moneyReturn为100
public CashReturn(string moneyCondition, string moneyReturn)
{
this.moneyCondition = double.Parse(moneyCondition);
this.moneyReturn = double.Parse(moneyReturn);
}
public override double acceptCash(double money)
{
double result = money;
//若大于返利条件,则需要减去返利值
if (money >= moneyCondition)
result = money - Math.Floor(money / moneyCondition) * moneyReturn;
return result;
}
}
}
CashSuper.cs:
namespace 商场管理软件
{
//现金收取父类
abstract class CashSuper
{
//抽象方法:收取现金,参数为原价,返回为当前价
public abstract double acceptCash(double money);
}
}
Form1.cs:
using System;
using System.Windows.Forms;
namespace 商场管理软件
{
//策略对象的的创建在上下文类中完成,即策略对象的创建是对用户保密的
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
//客户端窗体程序(主要部分)
double total = 0.0d;
private void btnOk_Click(object sender, EventArgs e)
{
//利用简单工厂模式根据下拉选择框,生成相应的对象
CashContext csuper = new CashContext(cbxType.SelectedItem.ToString());
double totalPrices = 0d;
//通过多态,可以得到收取费用的结果
totalPrices = csuper.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
//展示计价结果
lbxList.Items.Add("单价:" + txtPrice.Text + " 数量:" + txtNum.Text + " "
+ cbxType.SelectedItem + " 合计:" + totalPrices.ToString());
lblResult.Text = total.ToString();
}
private void btnClear_Click(object sender, EventArgs e)
{
total = 0d;
txtPrice.Text = "0.00";
txtNum.Text = "0";
lbxList.Items.Clear();
lblResult.Text = "0.00";
}
}
}
CashAcceptType.xml:
<?xml version="1.0" encoding="utf-8" ?>
<CashAcceptType>
<type>
<name>正常收费</name>
<class>CashNormal</class>
<para></para>
</type>
<type>
<name>满300返100</name>
<class>CashReturn</class>
<para>300,100</para>
</type>
<type>
<name>满200返50</name>
<class>CashReturn</class>
<para>200,50</para>
</type>
<type>
<name>打8折</name>
<class>CashRebate</class>
<para>0.8</para>
</type>
<type>
<name>打7折</name>
<class>CashRebate</class>
<para>0.7</para>
</type>
</CashAcceptType>
策略+反射完整源码
CashSuper.cs:
namespace 商场管理软件
{
abstract class CashSuper
{
public abstract double acceptCash(double money);
}
}
CashNormal.cs:
namespace 商场管理软件
{
class CashNormal : CashSuper
{
public override double acceptCash(double money)
{
return money;
}
}
}
CashRebate.cs:
namespace 商场管理软件
{
class CashRebate : CashSuper
{
private double moneyRebate = 1d;
public CashRebate(string moneyRebate)
{
this.moneyRebate = double.Parse(moneyRebate);
}
public override double acceptCash(double money)
{
return money * moneyRebate;
}
}
}
CashReturn.cs:
using System;
namespace 商场管理软件
{
class CashReturn : CashSuper
{
private double moneyCondition = 0.0d;
private double moneyReturn = 0.0d;
public CashReturn(string moneyCondition,string moneyReturn)
{
this.moneyCondition = double.Parse(moneyCondition);
this.moneyReturn = double.Parse(moneyReturn);
}
public override double acceptCash(double money)
{
double result = money;
if (money >= moneyCondition)
result=money- Math.Floor(money / moneyCondition) * moneyReturn;
return result;
}
}
}
CashContext.cs:
namespace 商场管理软件
{
class CashContext
{
private CashSuper cs;
//设置上下文中的策略实例对象
public void setBehavior(CashSuper csuper)
{
this.cs = csuper;
}
public double GetResult(double money)
{
return cs.acceptCash(money);
}
}
}
Form1.cs:
using System;
using System.Data;
using System.Windows.Forms;
using System.Reflection;
namespace 商场管理软件
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
DataSet ds;//用于存放配置文件信息
double total = 0.0d;//用于总计
/// <summary>
/// 在程序加载时,读取指定文件中的所有内容
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Form1_Load(object sender, EventArgs e)
{
//读配置文件 --在程序运行的路径下
ds = new DataSet();
ds.ReadXml(Application.StartupPath + "\\CashAcceptType.xml");
//将读取到的记录绑定到下拉列表框中
foreach (DataRowView dr in ds.Tables[0].DefaultView)
{
cbxType.Items.Add(dr["name"].ToString());
}
cbxType.SelectedIndex = 0;
}
private void btnOk_Click(object sender, EventArgs e)
{
//实例化一个上下文对象
CashContext cc = new CashContext();
//根据用户的选项,查询用户选择项的相关行
DataRow dr = ((DataRow[])ds.Tables[0].Select("name='" + cbxType.SelectedItem.ToString()+"'"))[0];
//声明一个参数的对象数组
object[] args =null;
//若有参数,则将其分割成字符串数组,用于实例化时所用的参数
if (dr["para"].ToString() != "")
args = dr["para"].ToString().Split(',');
//通过反射实例化出相应的算法对象
cc.setBehavior((CashSuper)Assembly.Load("商场管理软件").CreateInstance("商场管理软件." + dr["class"].ToString(), false, BindingFlags.Default, null, args, null, null));
double totalPrices = 0d;
totalPrices = cc.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
lbxList.Items.Add("单价:" + txtPrice.Text + " 数量:" + txtNum.Text + " "+cbxType.SelectedItem+ " 合计:" + totalPrices.ToString());
lblResult.Text = total.ToString();
}
private void btnClear_Click(object sender, EventArgs e)
{
total = 0d;
txtPrice.Text = "0.00";
txtNum.Text = "1";
lbxList.Items.Clear();
lblResult.Text = "0.00";
}
}
}