读书笔记15：备忘录模式

1、  概念

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复至保存时的状态。

2、  模型

角色：

Originator(发起者)——创建备忘录Memorandum，并且根据需要决定，需要保存那些状态。

Memorandum(备忘录)——负责存储Originator对象的内部状态，并防止Originator以外的对象访问这个备忘录。

Caretaker(管理者)——负责保存备忘录。

程序模型：

//发起者，需要保存状态的对象

[csharp]  view plain copy print ?

1. public class Originator  
2.    {  
3.        private string stateString1;  
4.   
5.        public string StateString1  
6.        {  
7.            get { return stateString1; }  
8.   
9.            set { stateString1 = value; }  
10.        }  
11.   
12.        private string stateString2;  
13.   
14.        public string StateString2  
15.        {  
16.            get { return stateString2; }  
17.   
18.            set { stateString2 = value; }  
19.        }  
20.   
21.   
22.        public Memorandum CreateMemorandum()  
23.        {  
24.            return new Memorandum(stateString1, stateString2);  
25.        }  
26.   
27.        public void SetMemorandum(Memorandum memorandum)  
28.        {  
29.            StateString1 = memorandum.StateString1;  
30.   
31.            StateString2 = memorandum.StateString2;  
32.        }  
33.   
34.        public void ShowMemorandum()  
35.        {  
36.            Console.WriteLine("当前状态：");  
37.   
38.            Console.WriteLine("StateString1={0}", stateString1, stateString2);  
39.   
40.            Console.WriteLine("StateString2={0}", stateString1, stateString2);  
41.        }  
42.    }  

// 存储Originator，其中包括的参数和要存的Originator参数一致

[csharp]  view plain copy print ?

1. public class Memorandum  
2.    {  
3.        private string stateString1;  
4.   
5.        private string stateString2;  
6.   
7.        public Memorandum(string state1, string state2)  
8.        {  
9.            this.stateString1 = state1;  
10.   
11.            this.stateString2 = state2;  
12.        }  
13.   
14.        public string StateString1  
15.        {  
16.            get { return stateString1; }  
17.        }  
18.   
19.        public string StateString2  
20.        {  
21.            get { return stateString2; }  
22.        }  
23.    }  

管理者：

[csharp]  view plain copy print ?

1. public class CareTaker  
2.    {  
3.        private Memorandum memorandum;  
4.   
5.        public Memorandum MemorandumClass  
6.        {  
7.            get { return memorandum; }  
8.   
9.            set { memorandum = value; }  
10.        }  
11.   
12.    }  

调用：

[csharp]  view plain copy print ?

1. static void Main(string[] args)  
2. {  
3.     //发起者参数状态初始化  
4.     Originator originator = new Originator();  
5.   
6.     originator.StateString1 = "参数StateString1——初始化1";  
7.   
8.     originator.StateString2 = "参数StateString2——初始化1";  
9.   
10.     originator.ShowMemorandum();  
11.   
12.     //保存一份备份  
13.     CareTaker careTaker = new CareTaker();  
14.   
15.     careTaker.MemorandumClass = originator.CreateMemorandum();  
16.   
17.     //发起者参数状态改变了  
18.     originator.StateString1 = "参数StateString1——初始化2";  
19.   
20.     originator.StateString2 = "参数StateString2——初始化2";  
21.   
22.     originator.ShowMemorandum();  
23.   
24.     //读取保存的进度  
25.     originator.SetMemorandum(careTaker.MemorandumClass);  
26.   
27.     originator.ShowMemorandum();  
28.   
29.     Console.ReadKey();  
30. }  

结果：

   

    备忘录模式，实际就是将一个类的当前状态保存一份放着，当状态改变以后，后面需要的时候再去读取保存的状态。而怎么去保存呢，Memorandum承担了保存参数的状态。如果一个类没有行为，而只有属性的话，那么Memorandum就可以写成和发起者一样的类型，保存的时候就可以保存发起者的实例。