设计模式—State

GOF定义:

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

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

先看一张截图:

1

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

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

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

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

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

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

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

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

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

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

   1:    public enum HandleType
   2:      {
   3:          New,
   4:          Update
   5:      }

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

   1:   public HandleType _HandleType;
   2:   public MainView(HandleType handleType)
   3:   {
   4:         this._HandleType = handleType;
   5:   }

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

   1:    this.btnSave.Click += (sender, e) =>
   2:                  {
   3:                      if (this._HandleType == HandleType.New)
   4:                      {
   5:                          //执行一些操作
   6:                          this._HandleType = HandleType.Update;
   7:                      }
   8:                      else if (this._HandleType == HandleType.Update)
   9:                      {
  10:                          //执行一些操作
  11:                      }
  12:                  };
  13:   
  14:   this.btnCancel.Click += (sender, e) =>
  15:                  {
  16:                      if (this._HandleType == HandleType.New)
  17:                      {
  18:                          //执行一些操作
  19:                      }
  20:                      else if (this._HandleType == HandleType.Update)
  21:                      {
  22:                          //执行一些操作
  23:                      }
  24:                  };
 

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

三,使用状态模式后:

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

   1:     public abstract class  MainViewStateBase
   2:      {
   3:          /// <summary>
   4:          /// MainView的保存操作
   5:          /// </summary>
   6:          /// <param name="mainView"></param>
   7:          public abstract void Save(MainView mainView);
   8:   
   9:          /// <summary>
  10:          /// MainView的放弃操作
  11:          /// </summary>
  12:          /// <param name="mainView"></param>
  13:          public abstract void Cancel(MainView mainView);
  14:      }

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

   1:  public MainViewStateBase _MainViewState;
   2:   
   3:  public MainView(MainViewStateBase mainViewState)
   4:  {
   5:       this._MainViewState = mainViewState;
   6:  }

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

   1:  this.btnSave.Click += (sender, e) =>
   2:                  {
   3:                      this._MainViewState.Save(this);
   4:                  };
   5:   
   6:  this.btnCancel.Click += (sender, e) =>
   7:                  {
   8:                      this._MainViewState.Cancel(this);
   9:                  };

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:      }
 
修改状态子类:
   1:    public class MainViewUpdateState: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:          /// <summary>
  14:          /// 修改时的放弃方法
  15:          /// </summary>
  16:          /// <param name="mainView"></param>
  17:          public override void Cancel(MainView mainView)
  18:          {
  19:              //执行一些操作
  20:              MessageBox.Show("修改时的放弃方法");
  21:          }
  22:      }

四,好处:

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

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

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

3.State对象可被共享.

自己理解:

1.对多态的完美应用.

posted @ 2011-08-09 15:55  风枫峰  阅读(2046)  评论(12编辑  收藏  举报