14、备忘录模式

备忘录模式：

备忘录模式（Memento），在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可以将该对象恢复到原先保存的状态。

示意图如下：

优点：
1、给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。
2、实现了信息的封装，使得用户不需要关心状态的保存细节。（有时一些发起人对象的内部信息必须保存在发起人对象以外的地方，但是必须要由发起人对象自己读取，这时，使用备忘录模式可以把复杂的发起人内部信息对其他的对象屏蔽起来，从而可以恰当地保持封装的边界。）
3、本模式简化了发起人类。发起人不再需要管理和保存其内部状态的一个个版本，客户端可以自行管理他们所需要的这些状态的版本。

缺点：消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

使用场景：1、需要保存/恢复数据的相关状态场景。 2、提供一个可回滚的操作。3、有时一些发起人对象的内部信息必须保存在发起人对象以外的地方，但是必须要由发起人对象自己读取，这时，可以使用备忘录模式把复杂的发起人内部信息对其他的对象屏蔽起来，以恰当地保持封装的边界。

注意事项：1、为了符合迪米特原则，还要增加一个管理备忘录的类。 2、为了节约内存，可使用原型模式+备忘录模式。

备忘录模式和原型模式这两个模式可以组合使用：在原发器对象（发起人对象）创建备忘录对象的时候，如果原发器对象中全部或者大部分的状态都需要保存，一个简洁的方式就是直接克隆一个原发器对象。也就是说，这个时候备忘录对象里面存放的是一个原发器对象的实例。

备忘录模式UML结构图：

Originator原发器）：创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态。
Memento（备忘录）：存储原发器的内部状态，备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。
Caretaker（负责人）：负责人又称为管理者，在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。

基本代码：

 	class Originator  //原发器
    {
        private string state;  //需要保存的属性，可能有多个
        public string State
        {
            get { return state; }
            set { state = value; }
        }

        public Memento CreateMemento()  //创建备忘录，将当前所需要保存的信息导入并实例化出一个Memento对象
        {
            return (new Memento(state));
        }

        public void SetMemento(Memento memento)  //恢复备忘录，将Memento导入并将相关数据恢复
        {
            state = memento.State;
        }

        public void Show()  //显示数据
        {
            Console.WriteLine("State=" + state);
        }
    }

    class Memento  //要保存的细节都封装在了Memento中，如果哪一天要修改保存细节也不用影响客户端，直接修改该类即可
    {
        private string state;

        public Memento(string state)  //构造方法，将相关数据导入
        {
            this.state = state;
        }

        public string State  //需要保存的数据属性，可以是多个
        {
            get { return state; }
        }
    }

    class Caretaker
    {
        private Memento memento;

        public Memento Memento  //得到或设置备忘录
        {
            get { return memento; }
            set { memento = value; }
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {

            Originator o = new Originator();
            o.State = "On";  //Originator初始状态，状态属性为“On”
            o.Show();

            Caretaker c = new Caretaker();
            c.Memento = o.CreateMemento();  //保存状态时，由于有了很好的封装，可以隐藏Originator的实现细节

            o.State = "Off";  //Originator更改状态属性为“On”
            o.Show();

            o.SetMemento(c.Memento);  //Originator恢复到初始状态
            o.Show();

            Console.Read();

        }
    }

例（游戏进度备忘）：

UML图：

代码实现：

	//游戏角色 	
	class GameRole
    {
        //生命力
        private int vit;
        public int Vitality
        {
            get { return vit; }
            set { vit = value; }
        }

        //攻击力
        private int atk;
        public int Attack
        {
            get { return atk; }
            set { atk = value; }
        }

        //防御力
        private int def;
        public int Defense
        {
            get { return def; }
            set { def = value; }
        }

        //状态显示
        public void StateDisplay()
        {
            Console.WriteLine("角色当前状态：");
            Console.WriteLine("体力：{0}", this.vit);
            Console.WriteLine("攻击力：{0}", this.atk);
            Console.WriteLine("防御力：{0}", this.def);
            Console.WriteLine("");
        }

        //保存角色状态
        public RoleStateMemento SaveState()
        {
            return (new RoleStateMemento(vit, atk, def));
        }

        //恢复角色状态
        public void RecoveryState(RoleStateMemento memento)
        {
            this.vit = memento.Vitality;
            this.atk = memento.Attack;
            this.def = memento.Defense;
        }


        //获得初始状态
        public void GetInitState()
        {
            this.vit = 100;
            this.atk = 100;
            this.def = 100;
        }

        //战斗
        public void Fight()
        {
            this.vit = 0;
            this.atk = 0;
            this.def = 0;
        }
    }

    //角色状态存储箱
    class RoleStateMemento
    {
        private int vit;
        private int atk;
        private int def;

        public RoleStateMemento(int vit, int atk, int def)
        {
            this.vit = vit;
            this.atk = atk;
            this.def = def;
        }

        //生命力
        public int Vitality
        {
            get { return vit; }
            set { vit = value; }
        }

        //攻击力
        public int Attack
        {
            get { return atk; }
            set { atk = value; }
        }

        //防御力
        public int Defense
        {
            get { return def; }
            set { def = value; }
        }
    }

    //角色状态管理者
    class RoleStateCaretaker
    {
        private RoleStateMemento memento;

        public RoleStateMemento Memento
        {
            get { return memento; }
            set { memento = value; }
        }
    }

	class Program
    {
        static void Main(string[] args)
        {

            //大战Boss前
            GameRole lixiaoyao = new GameRole();
            lixiaoyao.GetInitState();
            lixiaoyao.StateDisplay();

            //保存进度
            RoleStateCaretaker stateAdmin = new RoleStateCaretaker();
            stateAdmin.Memento = lixiaoyao.SaveState();

            //大战Boss时，损耗严重
            lixiaoyao.Fight();
            lixiaoyao.StateDisplay();

            //恢复之前状态
            lixiaoyao.RecoveryState(stateAdmin.Memento);

            lixiaoyao.StateDisplay();


            Console.Read();

        }
    }