带撤销步数限制的撤消重做功能实现

撤消重做我们业务中非常常用的功能，我这里写个带限制步数的撤销操作功能的基础实现。

先来了解下撤销重做操作的基本思路。

撤销的操作往往是先撤回最近的操作，重做则是重做最近一次的撤销操作。所以，撤销重做功能都是符合先进后出的逻辑。所以我们在选择的时候，可以直接采用栈来做实现。
为了避免撤销操作和重做操作的不一致性，我们需要定义一个对象，能够同时用于撤销和重做的具体操作行为，这样我们在做撤销和重做的操作时，就不至于会出现对不上的情况。
如果要实现撤销步数限制，那么我们就需要在撤销步数达到最大时，删除最前面多余的撤销步数。

撤销重做栈的实现

因为业务需要，我们这个栈需要提供删除超出的撤销操作，具体方法如下：

    /// <summary>
    /// 包含栈对象的节点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LinkedStackNode<T>
    {
        public LinkedStackNode(T value)
        {
            Value = value;
        }

        /// <summary>
        /// 下一个节点对象
        /// </summary>
        public LinkedStackNode<T> Next { get; internal set; }

        /// <summary>
        /// 上一个节点对象
        /// </summary>
        public LinkedStackNode<T> Pre { get; internal set; }

        /// <summary>
        /// 包含对象的值
        /// </summary>
        public T Value { get; }
    }

    /// <summary>
    /// 链表实现的栈，非线程安全
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LinkedStack<T>
    {
        public LinkedStack(int capacity)
        {
            _capacity = capacity;
        }

        /// <summary>
        /// 根节点
        /// </summary>
        private LinkedStackNode<T> _root;

        /// <summary>
        /// 叶子节点
        /// </summary>
        private LinkedStackNode<T> _leaf;

        /// <summary>
        /// 最大容量
        /// </summary>
        private int _capacity;

        /// <summary>
        /// 获取或设置<see cref="LinkedStack{T}"/>允许容纳的最大数量
        /// </summary>
        public int Capacity
        {
            get
            {
                return _capacity;
            }
            set
            {
                _capacity = value;
                if (_capacity < Count)
                {
                    RemoveLastOf(Count - _capacity);
                }
            }
        }

        /// <summary>
        /// <see cref="LinkedStack{T}"/>所包含<see cref="LinkedStackNode{T}"/>数量
        /// </summary>
        public int Count { get; private set; }

        /// <summary>
        /// 移除并返回顶端的<see cref="LinkedStackNode{T}"/>对象
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            if (_leaf == null)
                throw new Exception("当前栈为空");

            var value = _leaf.Value;
            var pre = _leaf.Pre;
            if (pre != null)
            {
                pre.Next = null;
            }

            _leaf = pre;

            Count--;

            return value;
        }

        /// <summary>
        /// 移除并返回顶端的<see cref="LinkedStackNode{T}"/>对象
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool TryPop(out T t)
        {
            if (_leaf == null)
            {
                t = default;
                return false;
            }
            t = Pop();
            return true;
        }

        /// <summary>
        /// 在栈顶端插入一个隶属于<see cref="LinkedStackNode{T}"/>的对象
        /// </summary>
        /// <param name="t"></param>
        public void Push(T t)
        {
            var node = new LinkedStackNode<T>(t);

            if (_root == null)
            {
                _root = node;
                _leaf = node;
            }
            else
            {
                if (_root.Next == null)
                {
                    _root.Next = node;
                    node.Pre = _root;
                    _leaf = node;
                }
                else
                {
                    _leaf.Next = node;
                    node.Pre = _leaf;
                    _leaf = node;
                }
            }

            if (Capacity - Count > 1)
            {
                Count++;
                return;
            }
            else
            {
                RemoveLastOf(1);
            }
        }

        /// <summary>
        /// 返回顶端的<see cref="LinkedStackNode{T}"/>对象并不进行移除
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            if (_leaf == null)
                throw new Exception("当前栈为空");

            return _leaf.Value;
        }

        /// <summary>
        /// 返回顶端的<see cref="LinkedStackNode{T}"/>对象并不进行移除
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool TryPeek(out T t)
        {
            if (_leaf == null)
            {
                t = default;
                return false;
            }
            t = Peek();
            return true;
        }

        /// <summary>
        /// 从栈底端移除节点
        /// </summary>
        /// <param name="count">需要移除的对象数量</param>
        /// <returns></returns>
        int RemoveLastOf(int count)
        {
            var c = Math.Min(count, Count);
            var current = _root;
            for (int i = 0; i < c; i++)
            {
                current = current.Next;
            }

            current.Pre = null;
            _root = current;
            Count -= c;
            return c;
        }
    }

定义可撤销操作接口IUndoable

    /// <summary>
    /// 表示可撤销的
    /// </summary>
    public interface IUndoable
    {
        /// <summary>
        /// 恢复
        /// </summary>
        void Redo();

        /// <summary>
        /// 撤销
        /// </summary>
        void Undo();
    }

定义撤销重做操作

    internal class UndoableOperator
    {
        internal UndoableOperator()
        {
            _redoCommandStack = new LinkedStack<IUndoable>(_defaultCapacity);
            _undoCommandStack = new LinkedStack<IUndoable>(_defaultCapacity);
        }

        readonly LinkedStack<IUndoable> _redoCommandStack;
        readonly LinkedStack<IUndoable> _undoCommandStack;

        /// <summary>
        /// 默认支持撤销重做的步数
        /// </summary>
        const int _defaultCapacity = 100;

        private int capacity = _defaultCapacity;

        public int Capacity
        {
            get
            {
                return capacity;
            }
            set
            {
                capacity = value;

                _redoCommandStack.Capacity = value;
                _undoCommandStack.Capacity = value;
            }
        }

        public bool CanUndo
        {
            get
            {
                return _undoCommandStack.Count > 0;
            }
        }

        public bool CanRedo
        {
            get
            {
                return _redoCommandStack.Count > 0;
            }
        }

        /// <summary>
        /// 插入一个新的操作
        /// </summary>
        /// <param name="undoable"></param>
        public void Insert(IUndoable undoable)
        {
            _undoCommandStack.Push(undoable);
        }

        /// <summary>
        /// 执行一个可撤销操作
        /// </summary>
        internal void Undo()
        {
            if (_undoCommandStack.TryPop(out IUndoable cmd))
            {
                cmd.Undo();
                _redoCommandStack.Push(cmd);
            }
        }

        /// <summary>
        /// 执行一个可恢复操作
        /// </summary>
        internal void Redo()
        {
            if (_redoCommandStack.TryPop(out IUndoable cmd))
            {
                cmd.Redo();
                _undoCommandStack.Push(cmd);
            }
        }
    }