设计模式—State

GOF定义:

STATE(状态模式):允许一个对象在其内部状态改变时改变它的行为.对象看起来似乎修改了它的类.

一,我为什么用状态模式:

先看一张截图:

目前系统中遇到很多这种类型的界面,它有很多职责:

1.当我们点击”新增”按钮进入这个界面的时候,它的职责是新增一个用户.

   a.保存按钮是保存新增用户的信息.

   b.放弃按钮是放弃所有已填写的信息,回到初始化状态.

2.当我们选中一条记录,点击”修改”按钮进入这个界面的时候,它的职责是修改一个用户

   a.保存按钮是保存修改后用户的信息.

   b.放弃按钮是放弃刚才修改的信息,回到初始状态.

3.当保存新增用户成功后,自动转入修改状态.

二,遇到这种情况,以前写得代码是这样的:

1.先定义一个操作类型的枚举:

  public enum HandleType
    {
        New,
        Update
    }

2.此页面的构造函数参数需要一个HandleType枚举(可以定义一个全局变量保存此值):

public HandleType _HandleType;
public MainView(HandleType handleType)
{
      this._HandleType = handleType;
}

3.然后在每个button的click事件中去判断这个状态:

 this.btnSave.Click += (sender, e) =>
               {
                   if (this._HandleType == HandleType.New)
                   {
                       //执行一些操作
                       this._HandleType = HandleType.Update;
                   }
                   else if (this._HandleType == HandleType.Update)
                   {
                       //执行一些操作
                   }
               };

this.btnCancel.Click += (sender, e) =>
               {
                   if (this._HandleType == HandleType.New)
                   {
                       //执行一些操作
                   }
                   else if (this._HandleType == HandleType.Update)
                   {
                       //执行一些操作
                   }
               };

4.当这个状态比较简单,然后操作也不是特别多,以后也没有什么扩展的需求的时候,这种方法还行,但是如果稍微多两种状态(比如审核,反审核),稍微多几个操作(比如上页,下页),这时候每个按钮都充斥着判断状态,还有很多地方有状态的改变,比如新增保存后进入修改状态,等等.这个时候往往我的代码越来越乱,以至于到最后自己都不想看自己写得代码,就盼着测试测不出什么问题,这个功能就这样算了.

三,使用状态模式后:

1.先定义一个状态基类,里边定义了这个对象的所有因状态不同而不同的方法:

   public abstract class  MainViewStateBase
    {
        /// <summary>
        /// MainView的保存操作
        /// </summary>
        /// <param name="mainView"></param>
        public abstract void Save(MainView mainView);

        /// <summary>
        /// MainView的放弃操作
        /// </summary>
        /// <param name="mainView"></param>
        public abstract void Cancel(MainView mainView);
    }

2.此页面的构造函数参数需要一个继承自MainViewStateBase的对象(可以定义一个全局变量储存此值):

public MainViewStateBase _MainViewState;

public MainView(MainViewStateBase mainViewState)
{
     this._MainViewState = mainViewState;
}

3.然后在每个button的click事件中,直接调用状态对象的对应方法:

this.btnSave.Click += (sender, e) =>
                {
                    this._MainViewState.Save(this);
                };

this.btnCancel.Click += (sender, e) =>
                {
                    this._MainViewState.Cancel(this);
                };

4.实现状态子类:

新增状态子类:

   1:      public class MainViewNewState:MainViewStateBase

   2:      {

   3:          /// <summary>

   4:          /// 新增时的保存方法

   5:          /// </summary>

   6:          /// <param name="mainView"></param>

   7:          public override void Save(MainView mainView)

   8:          {

   9:             //执行一些操作

  10:              MessageBox.Show("新增时的保存方法");

  11:   

  12:              //改变状态为修改状态

  13:              MainViewUpdateState updateState = new MainViewUpdateState();

  14:              mainView._MainViewState = updateState;

  15:          }

  16:   

  17:          /// <summary>

  18:          /// 修改时的放弃方法

  19:          /// </summary>

  20:          /// <param name="mainView"></param>

  21:          public override void Cancel(MainView mainView)

  22:          {

  23:              //执行一些操作

  24:              MessageBox.Show("新增时的放弃方法");

  25:          }

  26:      }

修改状态子类:

  public class MainViewUpdateState:MainViewStateBase
    {
        /// <summary>
        /// 修改时的保存方法
        /// </summary>
        /// <param name="mainView"></param>
        public override void Save(MainView mainView)
        {
            //执行一些操作
            MessageBox.Show("修改时的保存方法");
        }

        /// <summary>
        /// 修改时的放弃方法
        /// </summary>
        /// <param name="mainView"></param>
        public override void Cancel(MainView mainView)
        {
            //执行一些操作
            MessageBox.Show("修改时的放弃方法");
        }
    }

四,好处:

摘自: <<设计模式>>):

1.它将与特定状态相关的行为局部化,并且将不同状态的行为分割开来.

2.它使得状态转换显式化.

3.State对象可被共享.

自己理解:

1.对多态的完美应用.