状态模式（15）

今天我们来将状态模式，首先，我们来描述下面一个场景：

一、案例：

在工作过程中，根据时间段的不同，我们工作的状态也有所不同，下面，我们用简单的控制台应用程序，来实现一下这个场景。

        public static int Hour = 0;//钟点
        private static bool WorkFinished = false;//任务完成标记

        public static void WriteProgram()
        {
            if (Hour < 12)
            {
                Console.WriteLine($"当前时间：{Hour}点，上午工作，状态好");
            }
            else if (Hour < 13)
            {
                Console.WriteLine($"当前时间：{Hour}点，午饭 犯困 午休");
            }
            else if (Hour<17)
            {
                Console.WriteLine($"当前时间：{Hour}点，下午工作，状态一般");
            }
            else
            {
                if (WorkFinished)
                {
                    Console.WriteLine($"当前时间：{Hour}点，下班回家了。");
                }
                else
                {
                    Console.WriteLine($"当前时间：{Hour}点，加班哦。");
                }
            }
        }

客户端

        public static void Main()
        {
            Hour = 9;
            WriteProgram();
            Hour = 12;
            WriteProgram();
            Hour = 13;
            WriteProgram();
            Hour = 14;
            WriteProgram();
            Hour = 17;
            WriteProgram();
            Hour = 18;
            WriteProgram();
            Console.ReadKey();
        }

二、演绎

1、第一步演绎

看到上面用代码描述的场景，对于我们学了好多设计模式的小伙伴来讲，是不是显得特别的挫，最起码，我们也要抽象出一个类来呀。好，下面我们稍微改进一下代码：

    public class Work
    {
        private int hour;

        public int Hour
        {
            get
            {
                return hour;
            }

            set
            {
                hour = value;
            }
        }

        public bool Finish
        {
            get
            {
                return finish;
            }

            set
            {
                finish = value;
            }
        }

        private bool finish = false;

        public  void WriteProgram()
        {
            if ( hour< 12)
            {
                Console.WriteLine($"当前时间：{hour}点，上午工作，状态好");
            }
            else if (hour < 13)
            {
                Console.WriteLine($"当前时间：{hour}点，午饭 犯困 午休");
            }
            else if (hour < 17)
            {
                Console.WriteLine($"当前时间：{hour}点，下午工作，状态一般");
            }
            else
            {
                if (finish)
                {
                    Console.WriteLine($"当前时间：{hour}点，下班回家了。");
                }
                else
                {
                    Console.WriteLine($"当前时间：{hour}点，加班哦。");
                }
            }
        }
    }

客户端：

       public static void Main()
        {
            Work emergencyProjects = new Work();
            emergencyProjects.Hour = 9;
            emergencyProjects.WriteProgram();
            emergencyProjects.Hour = 13;
            emergencyProjects.WriteProgram();
            emergencyProjects.Hour = 16;
            emergencyProjects.WriteProgram();
            emergencyProjects.Hour = 18;
            emergencyProjects.WriteProgram();
            Console.ReadKey();
        }

上述代码，我们将工作写了一个Work类出来，让客户端来调用。

2、第二步演绎

那么我们看看我们改过之后的代码有什么问题呢？请看WriteProgram()方法，现在是这些状态分支，如果有更多的状态分支，那么这个方法将会很长，一个方法一大串代码。

如果一个方法代码过长，极有可能坏了味道。

我们的WriteProgram()方法中有很多判断的分支，这意味着它的责任过大了。无论任何状态，都需要通过它来改变，这其实是非常糟糕的。

面向对象设计其实就是希望做到代码责任的分解，我们的Work类其实违背了“单一职责”的原则。

比如WriteProgram()这个方法，判断这么多，任何的增加和减少，都需要修改这个方法，一不留神，可能会将其他的判断分支给修改了，这样对整个代码的维护风险是非常大的。

说白了，这也违反了“开放-封闭”原则。

通过上述的分析，我们可能会想到：将判断的每一个分支都写成一个一个的类，增加分支就相当于增加类，这样也不会影响到其他的类。

理论想的很好，但是如何实现呢？那就是我们今天要讲的状态模式。

状态模式：一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类。

状态模式主要解决：当控制一个对象状态转换的条件过于复杂时的情况，把状态的判断逻辑转移到不同状态的一系列类中去。可以把复杂的逻辑判断简化。当然，如果这个判断非常的简单，就没有必要用“状态模式”了。

好下面我们来看一下状态模式的结构

    //封装一个与Context的一个特定状态相关的行为
    abstract class State
    {
        public abstract void Handle(Context context);
    }
    //维护一个ConCreteState子类的实例，这个实例定义当前的状态
    class Context
    {
        private State state;

        public Context(State state)//定义Context的初始状态
        {
            this.State = state;
        }
        //可读写的状态属性，用于读取当前状态和设置当前状态
        internal State State
        {
            get
            {
                return state;
            }

            set
            {
                state = value;
                Console.WriteLine($"当前状态{state.GetType().Name}");
            }
        }
        //对请求做处理，并设置下一状态
        public void Request()
        {
            state.Handle(this);
        }
    }
    /// <summary>
    /// 具体的State类，实现一个与Context的一个状态相关的行为
    /// </summary>
    class ConcreteStateA:State
    {        
        public override void Handle(Context context)
        {
            //设置ConcreteStateA的下一状态是ConcreteStateB
            context.State = new ConcreteStateB();
        }
    }
    /// <summary>
    /// 具体的State类，实现一个与Context的一个状态相关的行为
    /// </summary>
    class ConcreteStateB : State
    {
        public override void Handle(Context context)
        {
            //设置ConcreteStateB的下一状态是ConcreteStateA
            context.State = new ConcreteStateA();
        }
    }

客户端调用：

        public static void Main()
        {
            Context c = new Context(new ConcreteStateA());//设置Context的初始状态为ConcreteStateA
            //不断的请求，同时更改状态
            c.Request();
            c.Request();
            c.Request();
            c.Request();
            c.Request();
            Console.ReadKey();
        }

状态模式的好处就是将特定状态的行为局部化，并将不同状态的行为分割开来。

好，通过这个模式，我们来应用到我们的案例中来：

    public abstract class State
    {
        public abstract void WrithProgram(Work w);
    }

    public class Work
    {
        private State current;

        public Work()
        {
            current = new ForenoonState();//工作初始化为上午工作状态，即上午9点
        }
        private double hour;

        public double Hour//"钟点"属性，状态转换的依据
        {
            get
            {
                return hour;
            }

            set
            {
                hour = value;
            }
        }

        public bool Finish
        {
            get
            {
                return finish;
            }

            set
            {
                finish = value;
            }
        }

        private bool finish = false;

        public bool TaskFinished//"任务完成"属性，是否能下班的依据
        {
            get { return finish; }
            set { finish = value; }
        }

        public void SetState(State s)
        {
            current = s;
        }

        public void WriteProgram()
        {
            current.WrithProgram(this);
        }
    }
  //上午工作状态
    public class ForenoonState : State
    {
        public override void WrithProgram(Work w)
        {
            if (w.Hour < 12)
            {
                Console.WriteLine($"当前时间：{w.Hour}点，上午工作，状态好");
            }
            else//超过12点，则转入中午工作状态
            {
                w.SetState(new NoonState());
                w.WriteProgram();
            }
        }
    }
    //中午工作状态
    public class NoonState:State
    {
        public override void WrithProgram(Work w)
        {
            if (w.Hour < 13)
            {
                Console.WriteLine($"当前时间：{w.Hour}点，午饭 犯困 休息");
            }
            else//超过13点，则转入下午工作状态
            {
                w.SetState(new AfternoonState());
                w.WriteProgram();
            }
        }
    }
    //下午工作状态
    public class AfternoonState:State
    {
        public override void WrithProgram(Work w)
        {
            if (w.Hour < 17)
            {
                Console.WriteLine($"当前时间：{w.Hour}点，下午工作，状态一般");
            }
            else//超过17点，则转入旁晚工作状态
            {
                w.SetState(new EveningState());
                w.WriteProgram();
            }
        }
    }
    //傍晚工作状态
    public class EveningState:State
    {
        public override void WrithProgram(Work w)
        {
            if (w.TaskFinished)//完成任务则进入下班状态
            {
                w.SetState(new RestState());
                w.WriteProgram();
            }
            else
            {
                Console.WriteLine($"当前时间：{w.Hour}点，加班！");
            }
        }
    }
    //下班状态
    public class RestState:State
    {
        public override void WrithProgram(Work w)
        {
            Console.WriteLine($"当前时间：{w.Hour}点，下班回家了");
        }
    }

客户端调用：

        public static void Main()
        {
            Work emergencyProject = new Work();
            emergencyProject.Hour = 9;
            emergencyProject.WriteProgram();
            emergencyProject.Hour = 10;
            emergencyProject.WriteProgram();
            emergencyProject.Hour = 12;
            emergencyProject.WriteProgram();
            emergencyProject.Hour = 13;
            emergencyProject.WriteProgram();
            emergencyProject.Hour = 14;
            emergencyProject.WriteProgram();
            emergencyProject.Hour = 17;
            emergencyProject.TaskFinished = false;
            emergencyProject.WriteProgram();
            Console.ReadKey();
        }

这就是状态模式了。

今天状态模式就讲到这里，下一篇我们会讲 适配器模式

---

本系列将持续更新，喜欢的小伙伴可以点一下关注和推荐，谢谢大家的支持。