C#学习笔记-备忘录模式

什么是备忘录模式？

　　备忘录模式（Memento）：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

　　 　　　　　　　　　　　　这样以后就可将该对象恢复到原先保存的状态。　

备忘录模式的组成

　  Originator（发起人）：负责创建一个备忘录Memento，用以记录当前时刻它的内部状态，并可使用备忘录恢复内部状态。

　　　　　　　　　　　　Originator可根据需要决定Memento存储Originator的哪些内部状态。

　　Memento（备忘录）：负责存储Originator对象的内部状态，并可防止Originator以外的其他对象访问Memento。

　　　　　　　　　　　　Memento有两个接口，Caretaker只能看到备忘录的窄接口，它只能将备忘录传递给其他对象。

　　　　　　　　　　　　Originator能够看到一个宽接口，允许它访问返回到现钱状态所需的所有数据。

　　Caretaker（管理者）：负责保存好备忘录Memento，不能对备忘录的内容进行操作或者检查。

备忘录模式具体实现

适配器模式的结构

　　

适配器模式的实现

Originator（发起人）类：

     class Originator
         {
             private string state;
             public string State
             {
                 get { return state; }
                 set { state = value; }
             }
             public void Show()
             {
                 Console.WriteLine("State={0}", State);
             }
             /// <summary>
             /// 从memento中调用之前保存好的参数
             /// </summary>
             public void SetMemento(Memento memento)
             {
                 this.state = memento.State;
             }
             /// <summary>
             /// 将当前的参数记录到Memento中去
             /// </summary>
             /// <returns></returns>
             public Memento CreateMemento()
             {
                 return (new Memento(state));
             }
         }

Memento（备忘录）类：

         class Memento
         {
             private string state;
             /// <summary>
             /// 备忘录中只需要变成只读就可以了
             /// </summary>
             public string State
             {
                 get { return state; }
             }
             public Memento(string state)
             {
                 this.state = state;
             }
         }

Caretaker（管理者）类：

         class Caretaker
         {
             private Memento memento;
             public Memento Memento
             {
                 get { return memento; }
                 set { memento = value; }
             }
         }

主函数调用

         static void Main(string[] args)
         {
             //初始化Originator,设定初始数据
             Originator o = new Originator();
             o.State = "O";
             o.Show();
             //保存Originator传递至Memento中
             Caretaker c = new Caretaker();
             c.Memento = o.CreateMemento();
             //修改Originator中的数据
             o.State = "T";
             o.Show();
             //调用备忘录中数据，重新更新数据
             o.SetMemento(c.Memento);
             o.Show();

             Console.Read();
         }

实例解析

　　为了深化理解，我们准备一个具体的实例来分析。

　　 在玩游戏的过程中，假设游戏有99关，我们从第1关开始，打到第15关的时候没有成功，这是我们就需要保存保存当前的进度，不然下次进来的时候我们就又得从第一关重新开始了。

分析：

　　我们需要保存当前的进度，这只是起到一个暂存的作用。

　　

具体实现：

     class Program
     {
         static void Main(string[] args)
         {
             //创建一个英雄角色李逍遥
             GameRole lixiaoyao = new GameRole();
             lixiaoyao.GetInitState();
             lixiaoyao.Show();
             //将李逍遥数据保存在备忘录中
             RoleStateCaretaker c = new RoleStateCaretaker();
             c.Menmento = lixiaoyao.SaveState();
             //让李逍遥参与战斗
             lixiaoyao.Fight();
             lixiaoyao.Show();
             //由于参与战斗后状态都发生了变化，所以重新调用以前的数据
             lixiaoyao.RecoverState(c.Menmento);
             lixiaoyao.Show();

             Console.Read();
         }
         class GameRole
         {
             private int vitality;
             private int attack;
             private int defense;
             //生命力
             public int Vitality
             {
                 get { return vitality; }
                 set { vitality = value; }
             }
             //攻击力
             public int Attack
             {
                 get { return attack; }
                 set { attack = value; }
             }
             //防御力
             public int Defense
             {
                 get { return defense; }
                 set { defense = value; }
             }
             //获取初始状态
             public void GetInitState()
             {
                 this.vitality = ;
                 this.defense = ;
                 this.attack = ;
             }
             //从Memento中获取到刚刚保存的数据
             public void RecoverState(RoleStateMemento memento)
             {
                 this.vitality = memento.Vitality;
                 this.defense = memento.Defense;
                 this.attack = memento.Attack;
             }
             //保存当前数据到Memento中
             public RoleStateMemento SaveState()
             {
                 return (new RoleStateMemento(vitality, attack, defense));
             }
             //显示当前状态
             public void Show()
             {
                 Console.WriteLine("State:");
                 Console.WriteLine("vitality={0}", vitality);
                 Console.WriteLine("Attack={0}", attack);
                 Console.WriteLine("Defense={0}", Defense);
             }
             //参与战队导致状态变得不好了
             public void Fight()
             {
                 this.vitality = ;
                 this.attack = ;
                 this.defense = ;
             }
         }
         class RoleStateMemento
         {
             private int vitality;
             private int attack;
             private int defense;
             //生命力
             public int Vitality
             {
                 get { return vitality; }
                 set { vitality = value; }
             }
             //攻击力
             public int Attack
             {
                 get { return attack; }
                 set { attack = value; }
             }
             //防御力
             public int Defense
             {
                 get { return defense; }
                 set { defense = value; }
             }
             //当角色将数据传递过来的时候需要调用这个函数
             public RoleStateMemento(int v,int a,int d)
             {
                 this.vitality = v;
                 this.defense = d;
                 this.attack = a;
             }
         }
         class RoleStateCaretaker
         {
             private RoleStateMemento memento;
             public RoleStateMemento Menmento
             {
                 get { return memento; }
                 set { memento = value; }
             }
         }
     }

备忘录模式的优缺点

　　Memento模式比较适用于功能比较复杂的，但是需要维护或者记录属性历史的类，或者需要保存的属性只是众多属性中的一个小部分时。Originator可以根据保存的Memento信息还原到前一状态。

备注：文中所有代码及知识点均来自于《大话设计模式》,本人属于边学边看边敲代码边总结的阶段。