设计模式-行为型-备忘录模式

备忘录模式（Memento）：

　　后悔药来啦！！！备忘录模式在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便在需要时能将该对象恢复到原先保存的状态。

备忘录模式的角色：

　　

　　1）发起人（Originator）：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。

　　2）备忘录（Memento）：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。

　　3）管理者（CareTaker）：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。

　　根据上述UML图实现代码： 

internal class Program
{
    private static void Main(string[] args)
    {
        Originator o = new Originator();
        o.State = "On";

        Caretaker c = new Caretaker();
        c.Memento = o.CreateMemento();

        o.State = "Off";
        o.SetMemento(c.Memento);
    }
}

/// <summary>
/// 备忘录
/// </summary>
public class Memento
{
    private string _state;

    public Memento(string state)
    {
        this._state = state;
    }

    public string State
    {
        get { return _state; }
    }
}

/// <summary>
/// 发起人
/// </summary>
public class Originator
{
    private string _state;

    public string State
    {
        get
        {
            return _state;
        }
        set
        {
            _state = value;
            Console.WriteLine("State = " + _state);
        }
    }

    public Memento CreateMemento()
    {
        return (new Memento(_state));
    }

    public void SetMemento(Memento memento)
    {
        Console.WriteLine("Restoring state...");
        State = memento.State;
    }
}

/// <summary>
/// 管理者
/// </summary>
public class Caretaker
{
    private Memento _memento;

    public Memento Memento
    {
        get
        {
            return _memento;
        }
        set
        {
            _memento = value;
        }
    }
}

　　现实生活中，我们往往会进行文档的备份或者SVN，git的快照。

internal class Program
{
    private static void Main(string[] args)
    {
        List<Document> docs = new List<Document>()
        {
            new Document{ Name="水浒传", Content="水浒传123131231"  },
            new Document{ Name="三国演义", Content="三国演义111111"  }
        };

        Originator originator = new Originator(docs);
        Caretaker caretaker = new Caretaker();
        DateTimeOffset time1 = new DateTimeOffset(DateTime.Now);
        caretaker.MementoDic.Add(time1, originator.CreateMemento());
        originator.GetShow();
        Console.WriteLine("====================================");
        Console.WriteLine("修改内容");
        docs[0].Content = "新水浒，搞笑ing";
        DateTimeOffset time2 = new DateTimeOffset(DateTime.Now);
        caretaker.MementoDic.Add(time2, originator.CreateMemento());
        originator.GetShow();
        Console.WriteLine("====================================");
        Console.WriteLine("回滚到第一阶段");
        originator.SetMemento(caretaker.MementoDic[time1]);
        originator.GetShow();
        Console.WriteLine("回滚到第二阶段");
        originator.SetMemento(caretaker.MementoDic[time2]);
        originator.GetShow();
    }
}

/// <summary>
/// 文件
/// </summary>
public class Document
{
    public string Name { get; set; }
    public string Content { get; set; }
}

/// <summary>
/// 备忘录
/// </summary>
public class Memento
{
    public List<Document> fileBack;

    public Memento(List<Document> docs)
    {
        this.fileBack = docs;
    }
}

/// <summary>
/// 发起人
/// </summary>
public class Originator
{
    //内部状态
    public List<Document> docs;

    public Originator(List<Document> docs)
    {
        this.docs = docs;
    }

    public Memento CreateMemento()
    {
        // 深拷贝传递对象
        var str = JsonConvert.SerializeObject(this.docs);
        return new Memento(JsonConvert.DeserializeObject<List<Document>>(str));
    }

    public void SetMemento(Memento memento)
    {
        Console.WriteLine("Restoring state...");
        docs = memento.fileBack;
    }

    /// <summary>
    /// 显示信息
    /// </summary>
    public void GetShow()
    {
        foreach (var doc in docs)
        {
            Console.WriteLine($"文件名：{doc.Name}，内容：{doc.Content}");
        }
    }
}

/// <summary>
/// 管理者
/// </summary>
public class Caretaker
{
    // 使用多个备忘录来存储多个备份点
    public Dictionary<DateTimeOffset, Memento> MementoDic { get; set; }

    public Caretaker()
    {
        MementoDic = new Dictionary<DateTimeOffset, Memento>();
    }
}

备忘录模式的优缺点：

　　优点：

　　　　1）给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。

　　　　2）实现了信息的封装，使得用户不需要关心状态的保存细节。

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

备忘录模式的应用场景：

　　1）需要保存/恢复数据的相关状态场景。

　　2）提供一个可回滚的操作。

参考：https://blog.csdn.net/heyangyi_19940703/article/details/51376570