设计模式笔记（十一） —— 状态模式

时间：2022-07-09 19:59:49

状态模式(State)：当一个内在对象的状态改变时允许改变其行为，这个对象看起来像是改变了其类。状态模式主要解决的是当控制一个对象状态改变的条件表达式过于复杂的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑化。
好处是将与特定状态的行为局部化，并且将不同状态的行为分割开来。将特定的状态相关行为都放入一个对象中，由于所有与状态相关的代码都存在某个ConcreteState当中，所以通过定义新的子类可以很容易地增加新的状态和转换，消除了庞大的条件分支语句，状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。
当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。 

  1. using System;
  3. /**
  4.  * 状态模式(State)：
  5.  *    当一个内在对象的状态改变时允许改变其行为，这个对象看起来像是改变了其类。状态模式主要解决的是当控制一个对象状态改变的条件表达式过于复杂的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑化。
  6.  *    好处是将与特定状态的行为局部化，并且将不同状态的行为分割开来。将特定的状态相关行为都放入一个对象中，由于所有与状态相关的代码都存在某个ConcreteState当中，所以通过定义新的子类可以很容易地增加新的状态和转换，消除了庞大的条件分支语句，状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖。
  7.      当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。
  8.  */
  9. namespace StuDesignMode.State
  10. {
  11.     #region 状态模式原始代码
  13.     //interface IState
  14.     //{
  15.     //    void Handle(Context context);    
  16.     //}
  18.     //class ConcreteStateA : IState
  19.     //{
  20.     //    public void Handle(Context context)
  21.     //    {
  22.     //        //设置A的下一状态是B
  23.     //        context.State = new ConcreteStateB();
  24.     //    }
  25.     //}
  27.     //class ConcreteStateB : IState
  28.     //{
  29.     //    public void Handle(Context context)
  30.     //    {
  31.     //        //设置B的下一状态是A
  32.     //        context.State = new ConcreteStateA();
  33.     //    }
  34.     //}
  36.     //class Context
  37.     //{
  38.     //    private IState _state;
  40.     //    public IState State
  41.     //    {
  42.     //        get { return this._state; }
  43.     //        set { this._state = value; Console.WriteLine("当前状态：",this._state.GetType().Name); }
  44.     //    }
  46.     //    public void Request()
  47.     //    {
  48.     //        this.State.Handle(this);
  49.     //    }
  50.     //}
  51.     #endregion
  53.     #region 模式示例
  55.     public interface IState
  56.     {
  57.         void WriteProgram(Work work);
  58.     }
  60.     /// <summary>
  61.     /// 上午状态
  62.     /// </summary>
  63.     public class ForenoonState : IState
  64.     {
  65.         public void WriteProgram(Work work)
  66.         {
  67.             if (work.Hour < 12)
  68.             {
  69.                 Console.WriteLine("当前时间：{0}点 上午工作，精神百倍！", work.Hour);
  70.             }
  71.             else
  72.             {
  73.                 work.CurrentState = new NoonState();
  74.                 work.WriteProgram();
  75.             }
  76.         }
  77.     }
  78.     /// <summary>
  79.     /// 中午状态
  80.     /// </summary>
  81.     public class NoonState : IState 
  82.     {
  83.         public void WriteProgram(Work work)
  84.         {
  85.             if (work.Hour < 13)
  86.             {
  87.                 Console.WriteLine("当前时间：{0}点 饿了，午饭；困了，午休。", work.Hour);
  88.             }
  89.             else
  90.             {
  91.                 work.CurrentState = new AfternoonState();
  92.                 work.WriteProgram();
  93.             }
  94.         }
  95.     }
  97.     /// <summary>
  98.     /// 下午工作状态
  99.     /// </summary>
  100.     public class AfternoonState : IState
  101.     {
  102.         public void WriteProgram(Work work)
  103.         {
  104.             if (work.Hour < 17)
  105.             {
  106.                 Console.WriteLine("当前时间：{0}点 下午状态还不错，继续努力！", work.Hour);
  107.             }
  108.             else
  109.             {
  110.                 //工作完成，下班回家
  111.                 if (work.TaskFinished)
  112.                 {
  113.                     work.CurrentState = new RestState();
  114.                     work.WriteProgram();
  115.                 }
  116.                 else//加班
  117.                 {
  118.                     work.CurrentState = new EveningState();
  119.                     work.WriteProgram();
  120.                 }
  121.             }
  122.         }
  123.     }
  125.     /// <summary>
  126.     /// 晚间工作状态
  127.     /// </summary>
  128.     public class EveningState : IState
  129.     {
  130.         public void WriteProgram(Work work)
  131.         {
  132.             if (work.TaskFinished)
  133.             {
  134.                 work.CurrentState = new RestState();
  135.                 work.WriteProgram();
  136.             }
  137.             else
  138.             {
  139.                 if (work.Hour < 21)
  140.                 {
  141.                     Console.WriteLine("当前时间：{0}点 加班哦，疲惫之急！", work.Hour);
  142.                 }
  143.                 else
  144.                 {
  145.                     work.CurrentState = new SleepingState();
  146.                     work.WriteProgram();
  147.                 }
  148.             }
  149.         }
  150.     }
  152.     /// <summary>
  153.     /// 下班了
  154.     /// </summary>
  155.     public class RestState : IState
  156.     {
  157.         public void WriteProgram(Work work)
  158.         {
  159.             Console.WriteLine("当前时间：{0}点 工作完成了，下班，回家！",work.Hour);
  160.         }
  161.     }
  163.     /// <summary>
  164.     /// 睡眠时间
  165.     /// </summary>
  166.     public class SleepingState : IState
  167.     {
  168.         public void WriteProgram(Work work)
  169.         {
  170.             Console.WriteLine("当前时间：{0}点 不行了，困死了，要睡觉！",work.Hour);
  171.         }
  172.     }
  173.     public class Work
  174.     {
  175.         /// <summary>
  176.         /// 工作状态 
  177.         /// </summary>
  178.         public IState CurrentState { get; set; }
  180.         /// <summary>
  181.         /// 当前时间
  182.         /// </summary>
  183.         public double Hour { get; set; }
  185.         /// <summary>
  186.         /// 工作是是否完成
  187.         /// </summary>
  188.         public bool TaskFinished { get; set; }
  190.         public Work()
  191.         {
  192.             //默认为上午工作状态
  193.             this.CurrentState = new ForenoonState();
  194.         }
  196.         public void WriteProgram()
  197.         {
  198.             this.CurrentState.WriteProgram(this);
  199.         }
  201.     }
  203.     //测试
  204.     class ClientTest
  205.     {
  206.         static void Main(string[] args)
  207.         {
  208.             Work worker = new Work();
  210.             worker.Hour = 9;
  211.             worker.WriteProgram();
  212.             worker.Hour = 11;
  213.             worker.WriteProgram();
  214.             worker.Hour = 12.50;
  215.             worker.WriteProgram();
  216.             worker.Hour = 14;
  217.             worker.WriteProgram();
  218.             worker.Hour = 16;
  219.             worker.TaskFinished = true;
  220.             worker.WriteProgram();
  221.             worker.Hour = 18;
  222.             worker.WriteProgram();
  223.             worker.Hour = 20;
  224.             worker.WriteProgram();
  225.             worker.Hour = 22;
  226.             worker.WriteProgram();
  228.             Console.WriteLine();
  229.         }
  230.     }
  231.     #endregion
  232. }
标签：

相关文章