设计模式篇——初探状态模式

状态模式简介：

状态模式允许一个对象基于内部状态而拥有不同的行为，这个对象看起来就好像修改了它的类。

Context将行为委托给当前状态对象。

把每个状态封装进一个类中，以此来解耦和扩展

状态装换可以有State类或者Context类来控制

状态模式通常会导致设计中的类的数目大量增加

状态类可以被多个Context实例共享。

 

　　假设我么现在有一个糖果机，可以投入“1块钱硬币“ ，转动把手，弹出一颗糖果。也可以不转动把手，把投入的钱币退回=》

 

　　我们可以从这个过程中分析得出，这个过程一共有4个状态=》没有投币，已经投币，发放（出售）糖果，糖果售罄；基于这四个状态，也有四个动作，投入钱币，退回钱币，转动把手，发放糖果（这个动作是在糖果机内部完成）。

　　基于这个我们创建一个GumballMachine（糖果机）类，糖果机实现了三个行为（投币，退币，摇动把手），构造函数中传入初始放入的糖果数量。糖果机中存在一个State的抽象类（下文中实现），代表所有状态的一个父类。setState方法更新状态。releaseBall方法弹出糖果，GetCount方法返回当前糖果数量。

    public class GumballMachine
    {
        //所有的状态(初始化只用到soldOut状态和noMoneyState状态)
        static State soldOutState;  //售罄
        static State noMoneyState;  //没有投币
        //static State hasMoneyState; //已投币
        //static State soldState;     //出售

        private int _count; //糖果数量
        private State _state = soldOutState; 
        public GumballMachine(int count)
        {
            _count = count;
            soldOutState = new SoldOutState(this);
            noMoneyState = new NoMoneyState(this);
            //hasMoneyState = new HasMoneyState(this);
            //soldState = new SoldState(this);
            if (_count > 0)
                _state = noMoneyState;      //糖果数量大于0，初始状态修改为未投币
        }
        public void insertMoney()           //投币
        {
            _state.insertMoney();
        }
        public void ejectMoney()            //退币
        {   
            _state.ejectMoney();
        }

        /// <summary>
        /// 转动把手
        /// </summary>
        public void turnCrank() 
        {
            _state.turnCrank();         //转动
            _state.dispense();          //发放糖果
        }          
        /// <summary>
        /// 更新状态
        /// </summary>
        /// <param name="state"></param>
        public void setState(State state)
        {
            _state = state;
        }
        /// <summary>
        /// 弹出糖果
        /// </summary>
        public void releaseBall()
        {
            Console.WriteLine("**************弹出一颗糖果●**************");
            if (_count != 0)
                _count = _count - 1;
        }
        /// <summary>
        /// 返回当前糖果状态
        /// </summary>
        /// <returns></returns>
        public int GetCount()
        {
            return _count;
        }
    }

　　我们基于所有状态抽象出一个父类State，这个父类有四个抽象方法，分别代表四个动作。（PS:这里抽象类或者接口由使用场景选择，抽象类可以让所有子类都初始化一些操作。）

    /// <summary>
    /// 状态的抽象类，所有状态都要继承自它
    /// </summary>
    public abstract class State
    {
        public abstract void insertMoney(); //放入硬币
        public abstract void ejectMoney();  //取出硬币
        public abstract void turnCrank();   //转动把手
        public abstract void dispense();    //发放糖果
    }

　　接下来我们实现这四个状态。

    /// <summary>
    /// 没有投钱
    /// </summary>
    public class NoMoneyState : State
    {
        private readonly GumballMachine _GumballMachine;
        public NoMoneyState(GumballMachine GumballMachine)
        {
            _GumballMachine = GumballMachine;
        }
        public override void dispense()
        {
            Console.WriteLine("需要先投币才能发放糖果");
        }

        public override void ejectMoney()
        {
            Console.WriteLine("没有投币不能退币");
        }

        public override void insertMoney()
        {
            Console.WriteLine("投入了1块钱，可以转动手柄弹出糖果。");
            _GumballMachine.setState(new HasMoneyState(_GumballMachine)); //状态转换
        }

        public override void turnCrank()
        {
            Console.WriteLine("没有投币不能转动");
        }
    }

    /// <summary>
    /// 已经投钱
    /// </summary>
    public class HasMoneyState : State
    {
        private readonly GumballMachine _GumballMachine;
        public HasMoneyState(GumballMachine GumballMachine)
        {
            _GumballMachine = GumballMachine;
        }
        public override void insertMoney()
        {
            Console.WriteLine("你已经投币，不需要重复投币，请等待。。");
        }
        public override void ejectMoney()
        {
            Console.WriteLine("退币。。现在机器是未投币");
            _GumballMachine.setState(new NoMoneyState(_GumballMachine));
        }
        public override void turnCrank()
        {
            Console.WriteLine("摇动把手");
            _GumballMachine.setState(new SoldState(_GumballMachine));
        }
        public override void dispense()
        {
            Console.WriteLine("发放糖果中（不正确的操作。。。）");
        }
    }

 /// <summary>
    /// 发放（出售）糖果
    /// </summary>
    public class SoldState : State
    {
        private readonly GumballMachine _GumballMachine;
        public SoldState(GumballMachine GumballMachine)
        {
            _GumballMachine = GumballMachine;
        }
        public override void dispense()
        {
            _GumballMachine.releaseBall();  //发放糖果  ,判断糖果数量，修改状态
            if (_GumballMachine.GetCount() > 0)
                _GumballMachine.setState(new NoMoneyState(_GumballMachine));
            else
            {
                Console.WriteLine("糖果售罄");
                _GumballMachine.setState(new SoldOutState(_GumballMachine));
            }
        }

        public override void ejectMoney()
        {
            Console.WriteLine("已转动把手，不能再退币（不正确动作）");
        }

        public override void insertMoney()
        {
            Console.WriteLine("正在发放糖果，不要重复投币（不正确动作）");
        }

        public override void turnCrank()
        {
            Console.WriteLine("不要重复转动把手（不正确操作）");
        }
    }

    /// <summary>
    /// 售罄
    /// </summary>
    public class SoldOutState : State
    {
        private readonly GumballMachine _GumballMachine;
        public SoldOutState(GumballMachine GumballMachine)
        {
            _GumballMachine = GumballMachine;
        }
        public override void dispense()
        {
            Console.WriteLine("糖果已售罄，不能发放糖果（不正确的操作）");
        }

        public override void ejectMoney()
        {
            Console.WriteLine("请先投币，再退币（不正确的操作）");
        }

        public override void insertMoney()
        {
            Console.WriteLine("糖果已售罄，不要再投币（不正确的操作）");
        }

        public override void turnCrank()
        {
            Console.WriteLine("请先投币，再转动把手（不正确的操作）");
        }
    }

　　要注意这四个状态都要继承自State抽象类，它们的构造函数中均需要传入GumballMachine，它们各个动作会使糖果机处于不同的状态。（例如NoMoneyState（未投币）状态下，执行insertMoney动作后，糖果机状态转换为HasMoneyState（已投币状态））。不同状态中存在一些无效的操作，这里我们直接打印了一句话，这里根据使用场景具体分析、处理。

　　接下来我们来运行一下=》我们初始化一个糖果机，放入100颗糖果。

　　接下来，然我们来看下状态模式的类图。Context上下文中存有一个State的超类，Context将不同的行为委托给具体的状态（没有投币，已经投币，发放（出售）糖果，糖果售罄）来实现；State封装Context的一组特定行为。具体的状态根据当前环境以实现不同的效果。

　　

 

　　这样做的好处是将State之间的逻辑解耦。例如，我们现在要再添加一个状态：幸运者！这样我们的系统就变成这样，在投币之后，我们将有1/10的概率成为幸运用户，这时候糖果机将给你两颗糖果。此时，我们添加一个状态LuckyState（幸运用户）。

 

    public class LuckyState : State            //是否是幸运
    {
        private readonly GumballMachine _GumballMachine;
        public LuckyState(GumballMachine GumballMachine)
        {
            _GumballMachine = GumballMachine;
        }

        public override void dispense()     
        {
            Console.WriteLine("你是幸运者！接下来我将给你两颗糖");
            _GumballMachine.releaseBall();
            if (_GumballMachine.GetCount() == 0)                            //糖果售罄
                _GumballMachine.setState(new SoldOutState(_GumballMachine));
            else
            {
                _GumballMachine.releaseBall();                              //给出第二颗糖果
                if (_GumballMachine.GetCount() > 0)
                    _GumballMachine.setState(new NoMoneyState(_GumballMachine));    //还有糖果，进入未投币状态
                else
                    _GumballMachine.setState(new SoldOutState(_GumballMachine));

            }
        }

        public override void ejectMoney()
        {
            Console.WriteLine("退币");
            _GumballMachine.setState(new NoMoneyState(_GumballMachine));
        }

        public override void insertMoney()
        {
            Console.WriteLine("已投币，不需要再次投币（不正确的操作）");
        }

        public override void turnCrank()
        {
            Console.WriteLine("你是幸运者,不需要摇动把手了，直接给你两颗糖（不正确的操作）");
        }
    }

　　我们还要修改我们的HasMoneyState，当成为幸运用户的时候，糖果机变为另外一个状态。我们来执行下=》

 　　这样我们就很容易的通过添加状态类来扩展我们的糖果机。

最后总结一下：

　　例子中的糖果机（GumballMachine）就是我们的上下文对象，然后我们的不同的状态变化时候，糖果机（GumballMachine）就会拥有不同的状态，不同的状态下会使GumballMachine有不同的行为（这样看来我们就把我们的Context上下文对象委托给了当前的状态对象），我们每一个状态都有一个单独的类，这些状态类都继承自State抽象类，所以我们可以随意的替换它们。我们要扩展一个状态也只需要添加一个继承自State的状态类。

　　同时，这样做的不好处就是我们的状态类会变得很多。