有限次数的Undo&Redo的C#实现

为了实现Undo和Redo，必须要在程序中保存起程序的运行状态，从而能够在Undo时跳转到前一个状态和在Redo时跳转到下一个状态。为了实现状态的维护，我采用了两个栈来分别保存Undo操作的状态和Redo操作的状态。

        public static Stack<MyCommand> undoStack = new Stack<MyCommand>();
        public static Stack<MyCommand> redoStack = new Stack<MyCommand>();

首先要识别哪些操作可以支持Undo和Redo操作。在我的小程序中，支持的操作主要有几个：textbox的textchanged，textbox和button的焦点，radiobutton、checkbox、combox、listbox选项的改变。

对于上述操作的实现，必须要实现一个MyCommand接口。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace UndoRedo
{
    public interface MyCommand
    {
        void execute(); //完成动作
        void undo(); //撤销动作
    }
}

每个操作都要继承自这个MyCommand接口，在操作类中包含有实现Undo和Redo操作所需要的属性，并且实现了接口中的execute（）和undo（）

创建了一个UndoRedo类，类中包含上面提到的两个栈，一个Undo栈，一个Redo栈。这个类实现了Undo方法和Redo方法，并且还有多个向Undo栈进行压栈的方法。

在Undo方法中：

检查Undo栈是否为空，不为空，则弹出一个MyCommand对象，把这个对象压入Redo栈中，执行这个对象的undo（）方法。

        /// <summary>
        /// 实现Undo操作
        /// </summary>
        /// <param name="times">撤销的次数</param>
        public static void Undo()
        {
            if (undoStack.Count != 0)
            {
                MyCommand myCommand = undoStack.Pop();
                myCommand.undo();
                redoStack.Push(myCommand);
            }
        }

在Redo方法中：

检查Redo栈是否为空，不为空，则弹出一个MyCommand对象，把这个对象压入Undo栈中，执行这个对象的execute（）方法。

      /// <summary>
        /// 实现Redo操作
        /// </summary>
        /// <param name="times">撤销的次数</param>
        public static void Redo()
        {
            if (redoStack.Count != 0)
            {
                MyCommand myCommand = redoStack.Pop();
                myCommand.execute();
                undoStack.Push(myCommand);
            }
        }

在向Undo栈进行压栈的方法中：

将MyCommand对象压入Undo栈中，并且将Redo栈清空。在这个方法里需要注意一点的是，我是实现有限次数的Undo和Redo，所以将栈的大小必须控制起来。如果栈中的元素个数小于指定次数，则进行压栈操作；如果栈中元素等于指定次数，则将栈中元素进行了一个处理。我是这样处理的：将栈内的元素用一个list保存起来，并且将除了栈底元素外的其他元素都重新压回栈内，从而实现了栈的元素个数的有限。下面这段代码以textbox的text改变事件作为例子，其他操作类似。

       public static void dealWithUndoStack(MyCommand command)
        {
            List<MyCommand> commandList = new List<MyCommand>();
            for (int i = 0; i < undoTimes; i++)
            {
                MyCommand cmd = undoStack.Pop();
                commandList.Add(cmd);
            }
            for (int j = undoTimes - 2; j >= 0; j--)
            {
                undoStack.Push(commandList[j]);
            }
        }

        /// <summary>
        /// 字符串的修改
        /// </summary>
        /// <param name="nstr">新字符串</param>
        public static void inStackForText(TextBox tb,string nstr,string ostr)
        {
            MyCommand command = new TextChangeCommand(tb,nstr,ostr);
            if (undoStack.Count < undoTimes)
                undoStack.Push(command);
            else if (undoStack.Count == undoTimes)
                dealWithUndoStack(command);
            redoStack.Clear();
        }

在完成了上面的几个步骤后，只需要在执行程序的不同操作的时候将该操作对应的Command类通过与inStackForText类似的方法，将类的对象压入Undo栈即可。当需要执行Undo操作的时候，调用UndoRedo类中的Undo方法；当需要执行Redo操作的时候，调用UndoRedo类中的Redo方法。

接着就是对于不同的操作，为其生成一个继承MyCommand接口的类即可。下面举个例子，依然是上面提到的textbox的text改变事件。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace UndoRedo
{
    class TextChangeCommand : MyCommand
    {
        private string newStr;
        private string oldStr;
        private TextBox mTextbox;

        public TextChangeCommand(TextBox tb,string ntext,string otext)
        {
            this.newStr = ntext;
            this.mTextbox = tb;
            this.oldStr = otext;
        }

        public void execute()
        {
            mTextbox.Text = this.newStr;
        }

        public void undo()
        {
            mTextbox.Text = this.oldStr;
        }
    }
}

这样的类的实现很简单，只需要将特定某类操作的操作对象和前后状态保存起来，并且实现接口中的方法即可。

总结一下：这样实现的好处就是不必把所需要用到Undo&Redo操作的控件的状态全保存起来，仅保存那一类操作所需的属性即可，让程序的可扩展性更好。当程序需要实现的功能发生改变的时候，只需要再实现一个继承自MyCommand接口的操作类，在UndoRedo类中为其生成一个压栈操作的方法即可。