备忘录模式(Memento Pattern)

对象状态的回溯：
    对象状态的变化无端，如何回溯/恢复对象在某个点的状态？
                       
动机：
    在软件构建过程中，某些对象的状态在转换过程中，可能由于某种需要，要求程序能够回溯到对象之前处于某个点时的状态。如果使用一些公有接口来让其他对象得到对象的状态，便会暴露对象的细节实现。
    如何实现对象状态的良好保存与恢复？但同时又不会因此而破坏对象本身的封装性。
意图：
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后可以将该对象恢复到原先保存的状态。

         
适用性：
    1.必须保存一个对象某一个时刻的(部分)状态，这样以后需要时它才能恢复到先前的状态。
    2.如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

代码实现：

 1       class  Memento
 2      {
 3           private   string  name;
 4           private   string  phone;
 5           private   double  budget;
 6 
 7           // Constructor
 8           public  Memento( string  name,  string  phone,  double  budget)
 9          {
10               this .name  =  name;
11               this .phone  =  phone;
12               this .budget  =  budget;
13          }
14           // Properties
15           public   string  Name
16          {
17               get  {  return  name; }
18               set  { name  =  value; }
19          }
20           public   string  Phone
21          {
22               get  {  return  phone; }
23               set  { phone  =  value; }
24          }
25           public   double  Budget
26          {
27               get  {  return  budget; }
28               set  { budget  =  value; }
29          }
30      }

 1       class  ProspectMemory
 2      {
 3           private  Memento memento;
 4 
 5           // Property
 6           public  Memento Memento
 7          {
 8               set  { memento  =  value; }
 9               get  {  return  memento; }
10          }
11      }

 1     // Originator
 2       class  SalesProspect
 3      {
 4           private   string  name;
 5           private   string  phone;
 6           private   double  budget;
 7 
 8           // Properties
 9           public   string  Name
10          {
11               get  {  return  name; }
12               set  { name  =  value; Console.WriteLine( " Name: "   +  name); }
13          }
14           public   string  Phone
15          {
16               get  {  return  phone; }
17               set  { phone  =  value; Console.WriteLine( " Phone: "   +  phone); }
18          }
19           public   double  Budget
20          {
21               get  {  return  Budget; }
22               set  { budget  =  value; Console.WriteLine( " Budget: "   +  budget); }
23          }
24           public  Memento SaveMemento()
25          {
26              Console.WriteLine( " \nSaving state --\n " );
27               return   new  Memento(name, phone, budget);
28          }
29           public   void  RestoreMemento(Memento memento)
30          {
31              Console.WriteLine( " \nRestoring state --\n " );
32               this .Name  =  memento.Name;
33               this .Phone  =  memento.Phone;
34               this .Budget  =  memento.Budget;
35          }
36      }

 1      class  Program
 2      {
 3           static   void  Main( string [] args)
 4          {
 5              SalesProspect s  =   new  SalesProspect();
 6              s.Name  =   " xiaoming " ;
 7              s.Phone  =   " (010)65236523 " ;
 8              s.Budget  =   28000.0 ;
 9 
10               // Store internal state
11              ProspectMemory m  =   new  ProspectMemory();
12              m.Memento  =  s.SaveMemento();
13 
14               // Continue changing originator
15              s.Name  =   " deke " ;
16              s.Phone  =   " (029)85423657 " ;
17              s.Budget  =   80000.0 ;
18 
19               // Restore saved state 
20              s.RestoreMemento(m.Memento);
21 
22               // Wait for user 
23              Console.Read();
24          }
25      }

Memento需要注意的几个要点：
    1.备忘录(Memento)存储原发器(Originator)对象的内部状态，在需要时恢复原发器状态。Memento模式适用于“由原发器管理，却又必须存储在原发器之外的信息”。
    2.在实现Memento模式中，要防止原发器以外的对象访问备忘录对象。备忘录对象有两个接口，一个为原发器的宽接口;一个为其他对象使用的窄接口。
    3.在实现Memento模式时，要考虑拷贝对象状态的效率问题，如果对象开销比较大，可以采用某种增量式改变来改进Memento模式。