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 = 100;
                this.defense = 100;
                this.attack = 100;
            }
            //从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 = 0;
                this.attack = 0;
                this.defense = 0;
            }
        }
        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信息还原到前一状态。

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