设计模式（十八）备忘录

一、定义

在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样就可以在以后将对象恢复到原先保存的状态。备忘录模式是一种对象行为型模式，其别名为标记（Token）模式。
二、描述

备忘录模式的核心在于备忘录类以及用于管理备忘录的负责人类的设计，包含以下三个角色：

1、Originator（原发器）：原发器是一个普通类，它通过创建一个备忘录来存储其当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器。
2、Memento（备忘录）：备忘录用于存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。用户需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用，原发器的设计在不同的编程语言中实现机制会有所不同。
3、Caretaker（负责人）：负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，不能修改对象，也无须知道对象的实现细节。
三、例子

X公司欲开发一款中国象棋App，基于新手友好、及防误触等原因，设计App具有“悔棋”功能，可恢复到前一步

Chessman：原发器

1. public class Chessman
2. {
3.     public string Label { get; set; }
4.     public int X { get; set; }
5.     public int Y { get; set; }
7.     public Chessman(string label, int x, int y)
8.     {
9.         Label = label;
10.         X = x;
11.         Y = y;
12.     }
14.     // 保存状态
15.     public ChessmanMemento Save()
16.     {
17.         return new ChessmanMemento(Label, X, Y);
18.     }
20.     // 恢复状态
21.     public void Restore(ChessmanMemento memento)
22.     {
23.         Label = memento.Label;
24.         X = memento.X;
25.         Y = memento.Y;
26.     }
27. }

复制代码

ChessmanMemento：备忘录

1. public class ChessmanMemento
2. {
3.     public string Label { get; set; }
4.     public int X { get; set; }
5.     public int Y { get; set; }
7.     public ChessmanMemento(string label, int x, int y)
8.     {
9.         Label = label;
10.         X = x;
11.         Y = y;
12.     }
13. }

复制代码

MementoCaretaker：负责人

1. public class MementoCaretaker
2. {
3.     private IList<ChessmanMemento> mementoList = new List<ChessmanMemento>();
5.     public ChessmanMemento GetMemento(int i)
6.     {
7.         return mementoList[i];
8.     }
10.     public void SetMemento(ChessmanMemento memento)
11.     {
12.         mementoList.Add(memento);
13.     }
14. }

复制代码

Program：测试代码

1. private static int index = -1;
2. private static MementoCaretaker mementoCaretaker = new MementoCaretaker();
4. Chessman chess = new Chessman("车", 1, 1);
5. Play(chess);
6. chess.Y = 4;
7. Play(chess);
8. chess.X = 5;
9. Play(chess);
11. Undo(chess, index);
12. Undo(chess, index);
13. Redo(chess, index);
14. Redo(chess, index);
16. // 下棋
17. void Play(Chessman chess)
18. {
19.     // 保存备忘录
20.     mementoCaretaker.SetMemento(chess.Save());
21.     index++;
23.     Console.WriteLine("棋子 {0} 当前位置为 第 {1} 行 第 {2} 列", chess.Label, chess.X, chess.Y);
24. }
26. // 悔棋
27. void Undo(Chessman chess, int i)
28. {
29.     Console.WriteLine("---------- Sorry，俺悔棋了 ---------");
30.     index--;
31.     // 撤销到上一个备忘录
32.     chess.Restore(mementoCaretaker.GetMemento(i - 1));
34.     Console.WriteLine("棋子 {0} 当前位置为 第 {1} 行 第 {2} 列", chess.Label, chess.X, chess.Y);
35. }
37. // 撤销悔棋
38. void Redo(Chessman chess, int i)
39. {
40.     Console.WriteLine("---------- Sorry，撤销悔棋 ---------");
41.     index++;
42.     // 恢复到下一个备忘录
43.     chess.Restore(mementoCaretaker.GetMemento(i + 1));
45.     Console.WriteLine("棋子 {0} 当前位置为 第 {1} 行 第 {2} 列", chess.Label, chess.X, chess.Y);
46. }
47. Console.ReadLine();

复制代码

四、总结

1、优点

（1）备忘录模式提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原。
（2）备忘录模式实现了对信息的封装，一个备忘录对象是一种原发器对象状态的表示，不会被其他代码所改动。备忘录保存了原发器的状态，采用列表、堆栈等集合来存储备忘录对象，可以实现多次撤销操作。
2、缺点

（1）备忘录模式资源消耗过大，如果需要保存的原发器类的成员变量太多，就不可避免地需要占用大量的存储空间，每保存一次对象状态都需要消耗一定系统资源。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！