策略模式（strategy）

策略模式（strategy）：定义了算法家族，并封装起来，让它们之间可以相互替换，此模式让算法替换不影响使用算法的客户。

 

/// <summary>
    /// 抽象算法类
    /// </summary>
    abstract class Strategy
    { 
        //算法方法
        public abstract void Method();
    }

    /// <summary>
    /// 具体算法1
    /// </summary>
    class Method1 : Strategy
    {
        public override void Method()
        {
            Console.WriteLine("具体算法1");
        }
    }

    /// <summary>
    /// 具体算法2
    /// </summary>
    class Methord2 : Strategy
    {
        public override void Method()
        {
            Console.WriteLine("具体算法2");
        }
    }

    
    class Content
    {
        private Strategy methord;

        public Content(Strategy Methord)//初始化时传入具体的策略对象
        {
            this.methord = Methord;
        }

        public void GetMethord()
        {
            methord.Method();//执行策略对象方法
        }
    }


    //客户端
    class Client
    {
        void Main(string[] args)
        {
            Content content;
            Method1 m1 = new Method1();//生成一个策略
            content = new Content(m1);//将策略交给
            content.GetMethord();//执行策略

            Methord2 m2 = new Methord2();//生成一个策略
            content = new Content(m2);
            content.GetMethord();
            
        }        
    }

实例应用：商场结账时会有几种情况：1、正常原价结账；2、打八折；3、满300赠100  等多种方式

分析：该需求总结起来就是根据原价计算价格，都是结构相同但实现不同的算法，同时算法间经常替换

namespace WindowsFormsApplication1.Strategy
{
    /// <summary>
    /// 结算方法抽象父类
    /// </summary>
    abstract class CashBase
    {
        /// <summary>
        /// 计算收取多少现金
        /// </summary>
        /// <param name="Money">原价</param>
        /// <returns>应收价</returns>
        public abstract double AcceptCash(double Money);
    }
     
    /// <summary>
    /// 结算方法生产工厂
    /// </summary>
    class CashFactory
    {
        public static CashBase CreateCashAccepter(string AcceptType)
        {
            CashBase res = null;
            switch (AcceptType)
            {
                case "正常收费":
                    res = new CashNormal();
                    break;
                case "满300送100":
                    res = new CashReturen("300", "100");
                    break;
                case "打八折":
                    res = new CashRebate("0.8");
                    break;
            }
            return res;
        }
    }

    /// <summary>
    /// 结算方法控制
    /// </summary>
    class CashContex
    {
        private CashBase cashAccepter;

        public CashContex(CashBase cashAccepter)
        {
            this.cashAccepter = cashAccepter;
        }

        public double GetResult(double Money)
        {
            return cashAccepter.AcceptCash(Money);
        }
    }

    /// <summary>
    /// 正常收费
    /// </summary>
    class CashNormal:CashBase
    {
        public override double AcceptCash(double Money)
        {
            return Money;
        }
    }

    /// <summary>
    /// 打折收费
    /// </summary>
    class CashRebate:CashBase
    {
        private double moneyRebate = 1.0d;

        public CashRebate(string moneyRebate)
        {
            this.moneyRebate = double.Parse(moneyRebate);
        }

        public override double AcceptCash(double Money)
        {
            return Money * moneyRebate;
        }
    }

    /// <summary>
    /// 满款返款
    /// </summary>
    class CashReturen:CashBase
    {
        private double moneyCondition = 0.0d;
        private double moneyReturn = 0.0d;

        public CashReturen(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;
        }
    }

    /// <summary>
    /// 客户端代码
    /// </summary>
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            cbx_Type.Items.AddRange(new Object[] { "正常收费", "满300送100", "打八折" });
            cbx_Type.SelectedIndex = 0;
        }

        private void bt_OK_Click(object sender, EventArgs e)
        {
            Strategy.CashBase moneyAccepter = Strategy.CashFactory.CreateCashAccepter(cbx_Type.SelectedItem.ToString());
            lb_AcceptMoney.Text = moneyAccepter.AcceptCash(double.Parse(tbx_Number.Text.Trim()) * double.Parse(tbx_SigPrice.Text.Trim())).ToString();
        }
    }
}

 

注：代码中客户端获得具体结算方法中添加了简单工厂模式
回顾：策略模式（strategy）是一种定义一系列算法的方法 ，从概念上看，这些算法完成的是相同的工作，只是实现不同，它可以以相同的方式调用所有算法，减少了算法类与算法使用类之间的耦合。