状态模式(State Pattern)

    状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化。

    客户端程序如下

    2. {
    3.     //紧急项目
    4.     Work emergencyProjects = new Work();
    5.     emergencyProjects.Hour = 9;
    6.     emergencyProjects.WriteProgram();
    7.     emergencyProjects.Hour = 10;
    8.     emergencyProjects.WriteProgram();    
    9.     emergencyProjects.Hour = 12;
    10.     emergencyProjects.WriteProgram();
    11.     emergencyProjects.Hour = 13;
    12.     emergencyProjects.WriteProgram();    
    13.     emergencyProjects.Hour = 14;
    14.     emergencyProjects.WriteProgram();
    15.     emergencyProjects.Hour = 17;
    16.     emergencyProjects.WriteProgram();    
    18.     //emergencyProjects.WorkFinished = true;
    19.     emergencyProjects.TaskFinished = false;
    21.     emergencyProjects.WriteProgram();
    22.     emergencyProjects.Hour = 19;
    23.     emergencyProjects.WriteProgram();
    24.     emergencyProjects.Hour = 22;
    25.     emergencyProjects.WriteProgram();    
    27.     Console.Read();
    29. }

    此段代码有很大的问题。MartinFowler曾在《重构》中写过一个很重要的代码味道，叫做’Long Method’,方法如果过长其实极有可能有坏味道了。

    ‘Work’类的’WriteProgram’方法很长，而且有很多判断的分支，这也就意味着它的责任过大了。无论是任何状态，都需要通过它来改变，这实际上是很糟糕的。

    面对对象设计其实就是希望做到代码的责任分解。这个类违背了’单一职责原则’。而且由于’WriteProgram’的方法里面有这么多判断，使得任何需求的改动或增加，都需要更改这个方法。又违背了’开放－封闭原则’。这类有个解决方案，就是’状态模式’。

    将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于摸个ConcreteState中，所以通过定义新的字类可以很容易地增加新的状态与转换。这样做的目的就是为了消除庞大的条件分支语句。状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。

    当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。

    1. //抽象状态
    3. {
    4.     public abstract void WriteProgram(Work w);
    5. }

    上午工作状态

    中午工作状态

    1. public class NoonState: State
    3.     public override void WriteProgram (Work w)
    4.     {
    5.         if (w.hour < 13)
    6.         {
    7.             Console.WriteLine("当前时间:{0}点 中午"，w.Hour);
    8.         } else
    9.         {
    10.             w.SetState(new AfterNoonState());
    11.             w.WriteProgram();
    12.         }
    13.     }
    14. }

    下午工作状态

    1. public class AfterNoonState: State
    2. {
    3.     public override void WriteProgram (Work w)
    4.     {
    5.         if (w.hour < 13)
    6.         {
    7.             Console.WriteLine("当前时间:{0}点 下午"，w.Hour);
    8.         } else
    9.         {
    10.             w.SetState(new EveningState());
    11.             w.WriteProgram();
    12.         }
    13.     }
    14. }

    睡眠状态

    1. public class SleepingState: State
    2. {
    3.     public override void WriteProgram (Work w)
    4.     {
    5.         if (w.hour < 13)
    6.         {
    7.         }
    8.     }

    下班休息状态

    1. public class RestState: State
    2. {
    3.     public override void WriteProgram(Work w)
    4.     {
    5.         Console.WriteLine("当前时间:{0}点 下班回家了。"，w.Hour);
    6.     }
    7. }

    工作类，此时没有了过长的分支判断语句

    客户端代码，没有任何改动。但我们的程序却更加灵活易变了。

    1. static void Main(string[[] args)
    2. {
    3.     //紧急项目
    4.     Work emergencyProjects = new Work();
    5.     emergencyProjects.Hour = 9;
    6.     emergencyProjects.WriteProgram();
    7.     emergencyProjects.Hour = 10;
    8.     emergencyProjects.WriteProgram();    
    9.     emergencyProjects.Hour = 12;
    10.     emergencyProjects.WriteProgram();
    11.     emergencyProjects.Hour = 13;
    12.     emergencyProjects.WriteProgram();    
    13.     emergencyProjects.Hour = 14;
    14.     emergencyProjects.WriteProgram();
    15.     emergencyProjects.Hour = 17;
    16.     emergencyProjects.WriteProgram();    
    18.     //emergencyProjects.WorkFinished = true;
    19.     emergencyProjects.TaskFinished = false;
    21.     emergencyProjects.WriteProgram();
    22.     emergencyProjects.Hour = 19;
    23.     emergencyProjects.WriteProgram();
    24.     emergencyProjects.Hour = 22;
    25.     emergencyProjects.WriteProgram();    
    27.     Console.Read();

    状态模式的主要优点在于封装了转换规则，并枚举可能的状态，它将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为，还可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数；其缺点在于使用状态模式会增加系统类和对象的个数，且状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱，对于可以切换状态的状态模式不满足“开闭原则”的要求。