设计模式之备忘录模式

1. 定义

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

简单来说，就是做一个备份，如果不小心修改了某类的状态，可以通过调用备份来找回之前的状态

如果用相同类的不同实例来保存，当做备份，那样就要把所有的public暴露出来，这个时候有时是不合适的，如果我们只要某类的一部分备份呢？
所以我们采用备忘录模式，备忘录模式主要是单独弄个备忘录的类来储存一些类的状态，而不是同一个类的不同实例来储存

2. 使用背景

有时一些对象的内部信息必须保存在对象以外的地方，但是必须要由对象自己读取，这时，使用备忘录可以把对象内部信息对其他对象屏蔽起来，从而可以恰当的保持封装的边界

或者说，当角色状态改变时，有时候这个状态无效，这时候就可以使用暂时储存起来的备忘录将状态还原了

3. 模式使用结构图

解释：

Originator(发起人):负责创建一个备忘录Memento，用以记录当前时刻它的内部状态，并可使用备忘录恢复内部状态。Originator可根据需要决定Memento存储Originator 的哪些内部状态。

Memento(备忘录):负责存储Originator对象的内部状态，并可防止Originator 以外的其他对象访问备忘录Memento。备忘录有两个接口，Caretaker 只能看到备忘录的窄接口，它只能将备忘录传递给其
他对象。Originator能够看到一个宽接口，允许它访问返回到先前状态所需的所有数据。

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

4. 备忘录模式的使用例子

题目：
假设我们在玩一个游戏，我们有一个游戏角色，这个角色有三种状态（生命力，攻击力，防御力），还要有几种方法（初始状态设置方法，读取存档方法，展示状态方法，保存状态创建存档方法）；另外有个管理存档的存档管理器，一个存档（备忘录）管理器可以有多个存档，具体读哪个可以自己决定；还有个存档（备忘录）类

结构图：

代码：

1.定义角色

	class GameRole
    {
        //体力
        public int Vitality { get; set; }
        //攻击力
        public int Attack { get; set; }
        //防御力
        public int Defense { get; set; }

        //展示状态
        public void DisplayState()
        {
            Console.WriteLine("当前角色状态：");
            Console.WriteLine("体力：{0}", Vitality);
            Console.WriteLine("攻击力：{0}", Attack);
            Console.WriteLine("防御力：{0}", Defense);
            Console.WriteLine("   ");
        }

        //设置初始状态
        public void SetInitState()
        {
            this.Vitality = 100;
            this.Attack = 100;
            this.Defense = 100;
        }

        //战斗
        public void Fight()
        {
            this.Vitality = 0;
            this.Attack = 0;
            this.Defense = 0;
        }

        //创建备忘录
        public RoleStateMemento CreateMemenon()
        {
            return new RoleStateMemento(Vitality,Attack,Defense); 
        }
        
        //恢复、使用备忘录
        public void RecoveryState(RoleStateMemento roleState)
        {
            this.Attack = roleState.Attack;
            this.Defense = roleState.Defense;
            this.Vitality = roleState.Vitality;
        }

    }

2.定义备忘录

//相当于一个存档，也就是一个备忘录
    class RoleStateMemento
    {
        //体力
        public int Vitality { get; set; }
        //攻击力
        public int Attack { get; set; }
        //防御力
        public int Defense { get; set; }
        public RoleStateMemento(int vit,int atk,int def)
        {
            Vitality = vit;
            Attack = atk;
            Defense = def;
        }

    }

3.定义存档（备忘录）管理器

 //相当于一个存档管理器，里面全是存档或者说备忘录，只不过这里没用集合，只是弄了个属性而已
    class RoleStateCaretaker
    {
        public RoleStateMemento  RoleStateMemento { get; set; }
    }
}

4.主程序

class Program
    {
        static void Main(string[] args)
        {
            GameRole gameRole = new GameRole();
            gameRole.SetInitState();
            gameRole.DisplayState();

            //角色数据备份、或者说弄个存档
            //1.建立一个存档管理器
            RoleStateCaretaker caretaker = new RoleStateCaretaker();
            //2.往存档管理器里塞入一个具体的存档
            caretaker.RoleStateMemento=gameRole.CreateMemenon();

            //改变角色状态
            gameRole.Fight();
            gameRole.DisplayState();

            //恢复角色状态
            gameRole.RecoveryState(caretaker.RoleStateMemento);
            gameRole.DisplayState();

            Console.ReadLine();

        }
    }

5. 全部程序

using System;

namespace 备忘录模式
{
    class Program
    {
        static void Main(string[] args)
        {
            GameRole gameRole = new GameRole();
            gameRole.SetInitState();
            gameRole.DisplayState();

            //角色数据备份、或者说弄个存档
            //1.建立一个存档管理器
            RoleStateCaretaker caretaker = new RoleStateCaretaker();
            //2.往存档管理器里塞入一个具体的存档
            caretaker.RoleStateMemento=gameRole.CreateMemenon();

            //改变角色状态
            gameRole.Fight();
            gameRole.DisplayState();

            //恢复角色状态
            gameRole.RecoveryState(caretaker.RoleStateMemento);
            gameRole.DisplayState();

            Console.ReadLine();

        }
    }

    class GameRole
    {
        //体力
        public int Vitality { get; set; }
        //攻击力
        public int Attack { get; set; }
        //防御力
        public int Defense { get; set; }

        //展示状态
        public void DisplayState()
        {
            Console.WriteLine("当前角色状态：");
            Console.WriteLine("体力：{0}", Vitality);
            Console.WriteLine("攻击力：{0}", Attack);
            Console.WriteLine("防御力：{0}", Defense);
            Console.WriteLine("   ");
        }

        //设置初始状态
        public void SetInitState()
        {
            this.Vitality = 100;
            this.Attack = 100;
            this.Defense = 100;
        }

        //战斗
        public void Fight()
        {
            this.Vitality = 0;
            this.Attack = 0;
            this.Defense = 0;
        }

        //创建备忘录
        public RoleStateMemento CreateMemenon()
        {
            return new RoleStateMemento(Vitality,Attack,Defense); 
        }
        
        //恢复、使用备忘录
        public void RecoveryState(RoleStateMemento roleState)
        {
            this.Attack = roleState.Attack;
            this.Defense = roleState.Defense;
            this.Vitality = roleState.Vitality;
        }

    }

    //相当于一个存档，也就是一个备忘录
    class RoleStateMemento
    {
        //体力
        public int Vitality { get; set; }
        //攻击力
        public int Attack { get; set; }
        //防御力
        public int Defense { get; set; }
        public RoleStateMemento(int vit,int atk,int def)
        {
            Vitality = vit;
            Attack = atk;
            Defense = def;
        }

    }

    //相当于一个存档管理器，里面全是存档或者说备忘录，只不过这里没用集合，只是弄了个属性而已
    class RoleStateCaretaker
    {
        public RoleStateMemento  RoleStateMemento { get; set; }
    }
}

6. 总结

这个模式也是有缺点的，角色状态需要完整存储到备忘录对象中，如果状态数据很大很多，那么在资源消耗上，备忘录对象会非常耗内存