undo redo 01 --no design pattern surpport!

最新推荐文章于 2023-05-17 21:42:28 发布

曾藩国

最新推荐文章于 2023-05-17 21:42:28 发布

阅读量287

点赞数

分类专栏：转载于他人的好东西文章标签： undo redo

转载于他人的好东西专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Multilevel Undo and Redo Implementation in C# - Part I (Using Single Object Representing Change Approach)

Razan Paul (Raju), 18 Feb 2009

How single object Representing Change Approach and Stack can be used to implement Undo/Redo operation in C#

Download source - 40.19 KB

优点：是实现简单，而不需要知道任何的设计模式，你就可以实现Undo/Redo。

不足：可维护性很低。代表该方法的对象包含很多额外信息，因为这里，单个对象用来容纳所有动作类型的数据。例如，对移动而言，我们只需保存移动相关的数据，而对调整尺寸，我们应该仅保存该操作相关的数据。所以，我们在保存冗余的数据。随着操作数目的增加，冗余也在增加。这并不是好的面向对象的设计。

Introduction

This is Part 1 in a series of articles on writing Multilevel Undo and Redo implementation in C#. This series shows Undo/Redo implementation in three approaches for the same problem along with how we can implement Undo/redo for different scenarios using these approaches. The approaches are using Single Object Representing Change, Command Pattern and Memento Pattern.

As we know, there is no generic solution for Undo/Redo and Undo/Redo implementation is very specific for each application. For this reason, at first each part in this series of articles discusses how that approach can model an arbitrary application, then it shows the implementation for a sample application. Here Undo/Redo operation is implemented using three different approaches for the same application so that you can compare each approach implementation with others and can pick one which best fits your requirements. The advantages and disadvantages of each approach are also discussed in each part.

Can You Read Each Part Independently?

Here you can read each part independently. To make each part independently readable, necessary information is repeated in each part.

Background

The approach that I have described in part I of this series of articles was written by me in a WPF commercial application when I was not aware of any pattern. After getting some pattern knowledge, I discovered that my solution had many design problems but I could not change the implementation as the application is working well according to requirements. Now by writing this series of articles, I am actually trying to learn from my mistakes. I have written this series of three part articles as a learning exercise, and I expect comments from you about the write up. Please let me know if you have any suggestion.

Basic Idea About Undo/Redo Implementation

As we know, an application changes its state after every operation. As an application is operated, it changes its state. So if someone would like to do undo he has to go to the previous state. So to enable going to the previous state, we need to store the states of the application while it runs. To support redo, we have to go to the next state from the present state.

To implement Undo/Redo, we have to store the states of the application and have to go to the previous state for undo and have to go to the next state for redo. So we have to maintain the states of the application to support Undo/Redo. To maintain the states of an application in all the three approaches, we use two stacks. One stack contains the states for undo operation. The second stack contains the states for redo operation. Undo operation pops the undo stack to get the previous state and sets the previous state to the application. In the same way, redo operation pops the redo stack to get the next state and sets the next state to the application.

Now we know Implementing Undo/ Redo operation is all about keeping state after each operation of the application. Now the question is how this approach keeps state. In this approach, changes of a single operation are kept in an object in which some attributes are redundant for this operation as state because here a single object is used to hold all types of action data.

What is the Single Object Representing Change Approach?

First of all, I want to say sorry because this name is given by me. Here a single object represents all the changes of all operations in an application. So after executing an operation, when you make an object of this type with the changes of the operation, you only use subset of attributes of this object and remaining attributes remain unused. For example, you have two operations in an application; these are height change and width change. So here this type of object contains two attributes: height and width. After executing height change method, when you make Change object, you will only set the height field of the change object and the other field remains unused.

How Can We Model Undo/Redo Operation for an Arbitrary Application using Single Object Representing Change Approach?

How an arbitrary application can be modeled using Single Object Representing Change Approach is discussed in the following steps:

Step 1

First identify for what operations you would like to support Undo/Redo. Then, identify in what container you will support undo/redo and also on what objects you would like to support undo/redo.

Step 2

Then identify the attributes that need to be saved for further use to handle each and every undo/redo operation.

Step 3

Then make a class (ChangeRepresentationObject) which contains all the attributes to support Undo/Redo for all operations. Also make an action type enum which will represent all the operations. This action type enum will be part of the ChangeRepresentationObject class.

Step 4

Than make a class named UndoRedo which contains two stacks of type ChangeRepresentationObject. One stack for undo operation and another operation id for redo operation. The class will implement the following interface:

Hide Copy Code

interface IUndoRedo
  {
      void Undo(int level);
      void Redo(int level);
      void InsertObjectforUndoRedo(ChangeRepresentationObject dataobject);
  }

Step 5

Then make the implementation of the methods: Undo, Redo, InsertObjectforUndoRedo.

In each Undo operation:

First you will check whether Undo stack is empty or not.
If not, then pop a ChangeRepresentationObject and push it to redo stack.
Check the action type.
Then based on action type, perform the undo operation using the ChangeRepresentationObjectattributes.

In each Redo operation, you will do almost the same as Undo.

First you will check whether Redo stack is empty or not.
If not, then pop a ChangeRepresentationObject and push it to undo stack.
Check the action type.
Then based on action type, perform the redo operation using the ChangeRepresentationObject attributes.

In InsertObjectforUndoRedo operation, you will just insert the data object into Undo Stack and clear the Redo stack.

Step 6

Then before performing each operation, call the InsertObjectforUndoRedo method to support undo/redo for all those operations. When Undo is clicked from UI, just call the Undo method of UndoRedo class and when Redo is clicked from UI, just call the redo method of UndoRedo class.

Sample Application Description

Here a simple WPF drawing application is used as an example to incorporate undo/redo operation. This WPF sample application supports four operations: Object Insert, Object Delete, Object Move, and Object Resize and has two types of geometric objects: Rectangle and Polygon. It uses Canvas as container to contain these geometric objects.

Now in this series of articles, we see how we can give Undo/Redo support in these four operations. In Part 1, the implementation is shown using Single Object Representing Change Approach. In Part 2, the implementation is shown using command pattern and in Part 3, the implementation is shown Using Memento pattern.

Undo/Redo Implementation of the Sample Application using Single Object Representing Change Approach

Undo/Redo implementation for the sample application using Single Object Representing Change Approach is discussed in the following:

Step 1

We will identify for what operations we are supporting Undo/Redo. Here for four operations we are supporting Undo/Redo. These are: Object Insert, Object Delete, Object Move, Object Resize. We are going to support Undo /Redo for Rectangle and Ellipse objects and here Container is Canvas.

Step 2

Now we will identify the parameters that need to be saved for further use to handle Undo/Redo. Geometric object moves its margin changes, so to support Undo/Redo for object move we need to keep margin. As object resizes, it changes its height, width and margin. So to support Undo/Redo for object resize, we need to keep height, width and margin. To support Undo /Redo for insert and delete, we will keep the reference of the geometric object.

Step 3

Now we will make ChangeRepresentationObject which contains Margin, Height, Width, Action type and geometric object reference to support Undo/Redo for all operations. Here geometric object reference is kept to get the reference when we want to make Undo/Redo on it. Also make an action type enum which will represent insert, delete, move and resize operation. This action type enum is used as part of the ChangeRepresentationObject.

Hide Copy Code

public enum ActionType
   {
       Delete = 0,
       Move = 1,
       Resize = 2,
       Insert = 3
   }

Hide Copy Code

public class ChangeRepresentationObject
{
    public ActionType Action;
    public Point Margin;
    public double Width;
    public double height;
    public FrameworkElement UiElement;
}

Steps 4 & 5

Than we make a class named UndoRedo which contains two stacks of type ChangeRepresentationObject. One stack is for undo operation and another operation id for redo operation. The class code is given below:

Hide Shrink

Copy Code

public partial class UnDoRedo : IUndoRedo
  {
      private Stack<ChangeRepresentationObject> _UndoActionsCollection =
                  new Stack<ChangeRepresentationObject>();
      private Stack<ChangeRepresentationObject> _RedoActionsCollection =
                  new Stack<ChangeRepresentationObject>();

      #region IUndoRedo Members

      public void Undo(int level)
      {
          for (int i = 1; i <= level; i++)
          {
              if (_UndoActionsCollection.Count == 0) return;

              ChangeRepresentationObject Undostruct = _UndoActionsCollection.Pop();
              if (Undostruct.Action == ActionType.Delete)
              {
                  Container.Children.Add(Undostruct.UiElement);
                  this.RedoPushInUnDoForDelete(Undostruct.UiElement);
              }
              else if (Undostruct.Action == ActionType.Insert)
              {
                  Container.Children.Remove(Undostruct.UiElement);
                  this.RedoPushInUnDoForInsert(Undostruct.UiElement);
              }
              else if (Undostruct.Action == ActionType.Resize)
              {
                  if (_UndoActionsCollection.Count != 0)
                  {
                      Point previousMarginOfSelectedObject = new Point
          (((FrameworkElement)Undostruct.UiElement).Margin.Left,
                          ((FrameworkElement)Undostruct.UiElement).Margin.Top);
                      this.RedoPushInUnDoForResize(previousMarginOfSelectedObject,
          Undostruct.UiElement.Width,
                          Undostruct.UiElement.Height, Undostruct.UiElement);
                      Undostruct.UiElement.Margin = new Thickness
          (Undostruct.Margin.X, Undostruct.Margin.Y, 0, 0);
                      Undostruct.UiElement.Height = Undostruct.height;
                      Undostruct.UiElement.Width = Undostruct.Width;
                  }
              }
              else if (Undostruct.Action == ActionType.Move)
              {
                  Point previousMarginOfSelectedObject = new Point
          (((FrameworkElement)Undostruct.UiElement).Margin.Left,
                      ((FrameworkElement)Undostruct.UiElement).Margin.Top);
                  this.RedoPushInUnDoForMove(previousMarginOfSelectedObject,
                          Undostruct.UiElement);
                  Undostruct.UiElement.Margin = new Thickness
          (Undostruct.Margin.X, Undostruct.Margin.Y, 0, 0);
              }
          }
      }

      public void Redo(int level)
      {
          for (int i = 1; i <= level; i++)
          {
              if (_RedoActionsCollection.Count == 0) return;

              ChangeRepresentationObject Undostruct = _RedoActionsCollection.Pop();
              if (Undostruct.Action == ActionType.Delete)
              {
                  Container.Children.Remove(Undostruct.UiElement);
                  this.PushInUnDoForDelete(Undostruct.UiElement);
              }
              else if (Undostruct.Action == ActionType.Insert)
              {
                  Container.Children.Add(Undostruct.UiElement);
                  this.PushInUnDoForInsert(Undostruct.UiElement);
              }
              else if (Undostruct.Action == ActionType.Resize)
              {
                  Point previousMarginOfSelectedObject = new Point
          (((FrameworkElement)Undostruct.UiElement).Margin.Left,
                      ((FrameworkElement)Undostruct.UiElement).Margin.Top);
                  this.PushInUnDoForResize(previousMarginOfSelectedObject,
                      Undostruct.UiElement.Width,
                      Undostruct.UiElement.Height, Undostruct.UiElement);
                  Undostruct.UiElement.Margin = new Thickness
          (Undostruct.Margin.X, Undostruct.Margin.Y, 0, 0);
                  Undostruct.UiElement.Height = Undostruct.height;
                  Undostruct.UiElement.Width = Undostruct.Width;
              }
              else if (Undostruct.Action == ActionType.Move)
              {
                  Point previousMarginOfSelectedObject = new Point
          (((FrameworkElement)Undostruct.UiElement).Margin.Left,
                      ((FrameworkElement)Undostruct.UiElement).Margin.Top);
                  this.PushInUnDoForMove(previousMarginOfSelectedObject,
                          Undostruct.UiElement);
                  Undostruct.UiElement.Margin = new Thickness
              (Undostruct.Margin.X, Undostruct.Margin.Y, 0, 0);
              }
          }
      }

      public void InsertObjectforUndoRedo(ChangeRepresentationObject dataobject)
      {
          _UndoActionsCollection.Push(dataobject);_RedoActionsCollection.Clear();
      }

     #endregion

Step 6

Before performing each operation, call the InsertObjectforUndoRedo method. When Undo is clicked from UI, we call the Undo method of UndoRedo class and when Redo is clicked from UI, we call the redo method of UndoRedo class.

Here I did not explicitly set the size of Undo stack and Redo stack, so the number of Undo/ Redo states that the application can hold will be based on the memory of system.

Change Management when using Single Object Representing Change Approach</strong />

If you want to support Undo /Redo for a new operation in single object representing change approach, you have to change a couple of things. You have to modify the object representing change, action type Enum and also change the code of undo and redo method. So its maintainability is low.

Advantages and Disadvantages when using Single Object Representing Change Approach</strong />

Its advantage is its simplicity to implement as without knowing any design pattern, you can implement undo/Redo.

Maintainability is low. The object that represents this approach contains extra information as here a single object is used to hold all types of action data. For example, for move we should keep only move related data and for resize, we should keep only resize related data. So we are keeping redundant data. As the number of operations increase, the redundancy increases. It is not a good object oriented design.

Sample Code

Here, a project has been attached which shows the Undo/Redo implementation Using Single Object Representing Change Approach.

Conclusion

Thanks for reading this write up. I hope that this article will be helpful for some people. If you guys have any questions, I would love to answer. I always appreciate comments.

History

Initial release – 14/02/09

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

我们如何在不同的场景下使用这些方法来实现Undo/Redo。这些方法是使用单个对象表示变化，命令模式和备忘录模式。

　　正如我们所知，Undo/Redo没有通用的解决方案，而Undo/Redo在每个应用程序中非常具体。处于这个原因，在该系列文章的开始部分，将讨论如何使用该方法建模任意的应用程序，然后展示一个简单应用程序的实现。

　　关于Undo/Redo实现的基本思想

　　正如我们所知，应用程序在每次操作后改变其状态。当操作应用程序时，它的状态会发生改变。所以，若有人想要做撤销，他不得不回到先前的状态。因此，为了能够回到先前状态，我们需要在应用程序运行时存储它的状态。要支持重做，我们不得不从目前状态跳到下一个状态。

　　为了实现Undo/Redo，我们不得不存储应用程序的状态并在撤销时跳到前一个状态而在重做时跳到下一个状态。因此我们需要维护应用程序的状态来支持Undo/Redo。在所有三种方法中，应用程序状态的维护用到了两个栈。一个栈包含用于撤销操作的状态，第二个包含用于重做的状态。撤销操作弹出撤销栈以获取前一个状态并将其设置给应用程序。同样的，重做操作弹出重做栈以获取下一个状态并将其设置给应用程序。

　　现在，我们知道了Undo/Redo的实现操作都是关于保持应用程序每次操作后的状态。现在的问题是该方法如何保存状态。本方法中，单个操作的改变被保存在一个对象中，有些属性为该操作作为状态是多余的，因为这里，单个对象被用于包含所有类型的动作数据。

　　什么是单个对象表示改变的方法？

　　首先，我对这是由我命名表示抱歉。这里，单个对象表示了应用程序中所有操作的所有改变。因此，当你准备了一个关于操作更改的类型的对象，在执行一次操作后，你仅使用了该对象属性的子集，而剩余属性仍旧没有被使用。例如，你在一个应用程序中有两个操作；它们是高度的改变和宽度的改变。因此，对象类型包含两个属性：高度和宽度。当你准备了变化对象，在执行高度更改方法后，你仅需设置变化对象的高度字段，而其他字段仍旧没有被使用。

　　如何应用单个对象表示变化的方法对任意应用程序Undo/Redo操作建模？

　　单个对象表示变化的方法如何对任意应用程序Undo/Redo操作建模将在以下步骤中讨论：

　　步骤1

　　首先识别出你希望哪些操作能支持Undo/Redo。然后，识别出你将在哪个容器下支持Undo/Redo以及你希望哪些对象支持Undo/Redo。

　　步骤2

　　为了进一步处理每个Undo/Redo操作，识别出需要被保存的属性。

　　步骤3

　　然后创建一个类（ChangeRepresentationObject），它包含支持全部操作Undo/Redo的所有属性。同样，准备一个动作类型enum，它将代表全部操作。这个动作类型enum是ChangeRepresentationObject类的一部分。

　　步骤4

　　然后创建一个名为UndoRedo的类，它包含两个类型的ChangeRepresentationObject栈。一个用于撤销操作，一个用于重做操作。该类将实现以下接口：

interface　IUndoRedo { void　Undo(int　level); void　Redo(int　level); void　InsertObjectforUndoRedo(ChangeRepresentationObject　dataobject); }　　

　　步骤5

　　然后实现具体方法：Undo、 Redo、InsertObjectforUndoRedo。

　　在每个Undo操作中：

　　◆首先检查Undo栈是否为空。

　　◆如果不是，则弹出一个ChangeRepresentationObject并将其压入重做栈。

　　◆检查动作类型。

　　◆然后基于动作类型，利用ChangeRepresentationObject的属性完成撤销操作。

　　在每个Redo操作中，你几乎做与Undo同样的事。

　　◆首先检查Redo栈是否为空。

　　◆如果不是，弹出一个ChangeRepresentationObject，然后将其压入撤销栈。

　　◆检查动作类型。

　　◆然后基于动作的类型，利用ChangeRepresentationObject属性完成重做操作。

　　在InsertObjectforUndoRedo操作中，你只要把数据对象插入Undo栈并清空Redo栈中。

　　步骤6

　　然后，在完成每次操作前，调用InsertObjectforUndoRedo方法以对所有操作提供Undo/Redo支持。在用户界面上点击Undo时，只需调用UndoRedo类的Undo方法，而在用户界面上点击Redo时，只需调用UndoRedo类的redo方法。

　　示例应用程序说明

　　这个示范WPF绘制应用程序用来作为结合Undo/Redo操作的案例。该WPF应用程序示例支持四种操作：插入对象、删除对象、移动对象和调整对象的尺寸，它还有两种类型的几何对象：矩形和多边形。它使用画布作为包含这些几何对象的容器。

　　现在，在此系列文章中，我们可以看到如何让这四个操作支持Undo/Redo。在第一部分，使用单个对象表示变化的方法实现。在第二部分，使用命令模式实现而在第三部分，使用备忘录模式实现。

　　使用单个对象表示变化的方法实现示范应用程序的Undo/Redo

　　利用单个对象表示变化的方法对示范应用程序Undo/Redo的实现将在以下步骤中讨论

　　步骤1

　　我们将识别出那些需要支持Undo/Redo的操作。这里有四个操作支持Undo/Redo。它们是：：插入对象、删除对象、移动对象和调整对象的尺寸。我们将对矩形和椭圆支持Undo/Redo，这里的容器是画布。

　　步骤2

　　现在我们将识别出那些进一步处理Undo/Redo所需的保存的参数。几何对象移动时其边距改变，因此要支持对象移动的Undo/Redo，要保存边距。当对象改变尺寸时，它的高度、宽度和边距改变。因此为支持对象尺寸调整的Undo/Redo，我们需要保存高度、宽度和边距。为了支持插入和删除的Undo/Redo操作，我们需要保存几何对象的引用。

　　步骤3

　　现在我们得到包含边距、高度、宽度、动作类型、几何对象引用的ChangeRepresentationObject以支持所有操作的Undo/Redo。这里的几何对象引用被保存以便我们在对其进行Undo/Redo时获取。同样使动作类型enum代表插入、删除、移动和调整尺寸操作。此动作类型enum被用作ChangeRepresentationObject的一部分。

CollapseCopy　Code public　enum　ActionType { Delete　=　0, Move　=　1, Resize　=　2, Insert　=　3 }　 CollapseCopy　Code public　class　ChangeRepresentationObject { public　ActionType　Action; public　Point　Margin; public　double　Width; public　double　height; public　FrameworkElement　UiElement; }

　　这里，已附上使用单个对象表示变化的方法实现Undo/Redo的项目。

　　步骤4&5

　　然后我们将包含两个ChangeRepresentationObject类型的栈的类命名为UndoRedo。一个栈用于撤销操作而另一个用于重做操作。类的代码如下：

CollapseCopy　Code public　partial　class　UnDoRedo　:　IUndoRedo { private　Stack　_UndoActionsCollection　=　 new　Stack(); private　Stack　_RedoActionsCollection　=　 new　Stack(); #region　IUndoRedo　Members public　void　Undo(int　level) { for　(int　i　=　1;　i　<=　level;　i ) { if　(_UndoActionsCollection.Count　==　0)　return; ChangeRepresentationObject　Undostruct　=　_UndoActionsCollection.Pop(); if　(Undostruct.Action　==　ActionType.Delete) { Container.Children.Add(Undostruct.UiElement); this.RedoPushInUnDoForDelete(Undostruct.UiElement); } else　if　(Undostruct.Action　==　ActionType.Insert) { Container.Children.Remove(Undostruct.UiElement); this.RedoPushInUnDoForInsert(Undostruct.UiElement); } else　if　(Undostruct.Action　==　ActionType.Resize) { if　(_UndoActionsCollection.Count　!=　0) { Point　previousMarginOfSelectedObject　=　new　Point (((FrameworkElement)Undostruct.UiElement).Margin.Left,　 ((FrameworkElement)Undostruct.UiElement).Margin.Top); this.RedoPushInUnDoForResize(previousMarginOfSelectedObject,　 Undostruct.UiElement.Width,　 Undostruct.UiElement.Height,　Undostruct.UiElement); Undostruct.UiElement.Margin　=　new　Thickness (Undostruct.Margin.X,　Undostruct.Margin.Y,　0,　0); Undostruct.UiElement.Height　=　Undostruct.height; Undostruct.UiElement.Width　=　Undostruct.Width; } } else　if　(Undostruct.Action　==　ActionType.Move) { Point　previousMarginOfSelectedObject　=　new　Point (((FrameworkElement)Undostruct.UiElement).Margin.Left, ((FrameworkElement)Undostruct.UiElement).Margin.Top); this.RedoPushInUnDoForMove(previousMarginOfSelectedObject,　 Undostruct.UiElement); Undostruct.UiElement.Margin　=　new　Thickness (Undostruct.Margin.X,　Undostruct.Margin.Y,　0,　0); } } } public　void　Redo(int　level) { for　(int　i　=　1;　i　<=　level;　i ) { if　(_RedoActionsCollection.Count　==　0)　return; ChangeRepresentationObject　Undostruct　=　_RedoActionsCollection.Pop(); if　(Undostruct.Action　==　ActionType.Delete) { Container.Children.Remove(Undostruct.UiElement); this.PushInUnDoForDelete(Undostruct.UiElement); } else　if　(Undostruct.Action　==　ActionType.Insert) { Container.Children.Add(Undostruct.UiElement); this.PushInUnDoForInsert(Undostruct.UiElement); } else　if　(Undostruct.Action　==　ActionType.Resize) { Point　previousMarginOfSelectedObject　=　new　Point (((FrameworkElement)Undostruct.UiElement).Margin.Left, ((FrameworkElement)Undostruct.UiElement).Margin.Top); this.PushInUnDoForResize(previousMarginOfSelectedObject,　 Undostruct.UiElement.Width,　 Undostruct.UiElement.Height,　Undostruct.UiElement); Undostruct.UiElement.Margin　=　new　Thickness (Undostruct.Margin.X,　Undostruct.Margin.Y,　0,　0); Undostruct.UiElement.Height　=　Undostruct.height; Undostruct.UiElement.Width　=　Undostruct.Width; } else　if　(Undostruct.Action　==　ActionType.Move) { Point　previousMarginOfSelectedObject　=　new　Point (((FrameworkElement)Undostruct.UiElement).Margin.Left,　 ((FrameworkElement)Undostruct.UiElement).Margin.Top); this.PushInUnDoForMove(previousMarginOfSelectedObject,　 Undostruct.UiElement); Undostruct.UiElement.Margin　=　new　Thickness (Undostruct.Margin.X,　Undostruct.Margin.Y,　0,　0); } } } public　void　InsertObjectforUndoRedo(ChangeRepresentationObject　dataobject) { _UndoActionsCollection.Push(dataobject);_RedoActionsCollection.Clear(); } #endregion

　　步骤6

　　在完成每个操作前，调用InsertObjectforUndoRedo方法。当用户界面上Undo被点击，我们调用UndoRedo类的Undo方法，而当用户界面上Redo被点击，我们调用UndoRedo类的redo方法。

　　这里，我们没有明确设置Undo栈和Redo栈的大小，因此，应用程序能具有的状态数目取决于系统的内存。

　　使用单个对象表示变化的方法时的变更管理

　　如果你想要用单个对象表示变化的方法来为新的操作支持Undo/Redo时，你不得不作一些改变。你不得不修改表示变化的对象，动作类型Enum并改变Undo/Redo方法的代码。所以，它的可维护性很低。

　　使用单个对象表示变化的方法的优缺点

　　它的优点是实现简单，而不需要知道任何的设计模式，你就可以实现Undo/Redo。

　　可维护性很低。代表该方法的对象包含很多额外信息，因为这里，单个对象用来容纳所有动作类型的数据。例如，对移动而言，我们只需保存移动相关的数据，而对调整尺寸，我们应该仅保存该操作相关的数据。所以，我们在保存冗余的数据。随着操作数目的增加，冗余也在增加。这并不是好的面向对象的设计。

曾藩国

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
undo redo 01 --no design pattern surpport!

Multilevel Undo and Redo Implementation in C# - Part I (Using Single Object Representing Change Approach)Razan Paul (Raju), 18 Feb 2009 4.90 (33 votes)Rate:vote 1vote 2vote 3vote 4vote 5 How single ...
复制链接

扫一扫

专栏目录