原型模式（浅克隆和深克隆）

原型模式是一种创建型设计模式,它通过复制一个已经存在的实例来返回新的实例,而不是新建实例.被复制的实例就是我们所称的原型,这个原型是可定制的.
原型模式多用于创建复杂的或者耗时的实例, 因为这种情况下,复制一个已经存在的实例可以使程序运行更高效,或者创建值相等,只是命名不一样的同类数据.

原型模式中的拷贝分为"浅拷贝"和"深拷贝":
浅克隆: 对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象.
深克隆: 对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制.

首先来看一些原型模式的实现代码，这里先运用浅克隆来实现 ，首先建立一个类来表示班级

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace 设计模式之原型模式
{
    /// <summary>
    /// 班级类
    /// </summary>
    public class Class
    {
        public int Num { get; set; }
        public string Remark { get; set; }
    }

    /// <summary>
    /// 学生类
    /// </summary>
    class StudentPrototype
    {
        //模拟复杂的构造函数
        private StudentPrototype()
        {
            Thread.Sleep(2000);
            long lResult = 0;
            for (int i = 0; i < 1000000000; i++)
            {
                lResult += i;
            }
            Console.WriteLine("{0}被构造..", this.GetType().Name);
        }

        private static StudentPrototype _StudentPrototype = null;

        static StudentPrototype()
        {
            _StudentPrototype = new StudentPrototype()
            {
                Id = 337,
                Name = "学友",
                Class=new Class()
                {
                    Num=1,
                    Remark="BIGDong"
                }
            };
        }
        /// <summary>
        /// 克隆出实体类
        /// </summary>
        /// <returns></returns>
        public static StudentPrototype CreatInstance()
        {
            //克隆一个对象（浅克隆）
            StudentPrototype studentPrototype = (StudentPrototype)_StudentPrototype.MemberwiseClone();
          
            return studentPrototype;
        }

        public int Id { get; set; }
        public string Name { get; set; }
        public Class Class{ get; set; }

        public void Study()
        {
            Console.WriteLine("{0}在学习设计模式",this.Name);
        }
    }
}

实例类可以调用MemberwiseClone函数来为该实体类克隆出一个副本，那么我们来做下测试

namespace 设计模式之原型模式
{
    class Program
    {
        static void Main(string[] args)
        {
            StudentPrototype stundet1 = StudentPrototype.CreatInstance();
            StudentPrototype stundet2 = StudentPrototype.CreatInstance();
            stundet1.Name = "华仔";
            stundet1.Id = 2;
            stundet1.Class.Num = 3;
            stundet1.Class.Remark = "郭富城";

            Console.WriteLine(string.Format("stundet1.Name是{0},stundet1.Id是{1},stundet1.Class.Num是{2},stundet1.Class.Remark是{3},"
            , stundet1.Name, stundet1.Id, stundet1.Class.Num, stundet1.Class.Remark));

            Console.WriteLine(string.Format("stundet2.Name是{0},stundet2.Id是{1},stundet2.Class.Num是{2},stundet2.Class.Remark是{3},"
        , stundet2.Name, stundet2.Id, stundet2.Class.Num, stundet2.Class.Remark));

            Console.ReadKey();
        }
    }
}

 

从调试可以看出这两个被使用浅克隆生成的对象，当第一个被对象修改值的时候，第二个对象里面的值对象并没有被覆盖掉，而第二个对象里的class引用类全被改变了

说到这里就要解释下，引用类型指向都是一个内存地址，而这个内存地址指向的是推里的一个值，上面的例子创建了两个对象都是指向同一块内存地址，所以只要改变一个的值

另外一个也会跟着改变（这和单例模式很像），然后这里还有一点说明，在StudentPrototype类里的string字段也是引用类型，为什么它没被覆盖掉呢？

在解释这个问题之前，我们上一段代码来解决上面的class不会被覆盖的，然后再解释string为什么不会被覆盖的问题

把上面赋值的地方之间生成一个新的对象，这样就将内存地址指向一个新的值

我们可以看到 现在class不会被覆盖掉了，其实string每次在赋值的时候也是这样子，重新生成一个内存地址，指向一个新的值，所以也不会被覆盖

而这种方式也正是我们讲的深克隆

我们也可以在类的构造函数里直接添加深克隆的代码，但是这样每一个新的类就得创建在构造函数写一大堆，是麻烦的，其实我们可以使用序列化的方式

来实习这一繁琐的步骤，首先要在类前加上序列化的特性

然后写一个创建序列化和反序列化类，通过反序列出来的对象都是重新生成的

namespace 设计模式之原型模式
{
    class SerializeHelper
    {
        /// <summary>
        /// 将一个对象转成字符串（序列化）
        /// </summary>
        /// <param name="targat">对象</param>
        /// <returns></returns>
        public static string Serializble(object targat)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                new BinaryFormatter().Serialize(stream, targat);
                return Convert.ToBase64String(stream.ToArray());
            }
        }

        /// <summary>
        /// 将字符串转成对象（反序列化）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="target">字符串</param>
        /// <returns></returns>
        public static T Derializable<T>(string target)
        {
            byte[] targetArray = Convert.FromBase64String(target);
            using (MemoryStream stream = new MemoryStream(targetArray))
            {
                return (T)(new BinaryFormatter().Deserialize(stream));
            }
        }

        /// <summary>
        /// 外界调用接口
        /// </summary>
        /// <typeparam name="T">泛型</typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T DeepClone<T>(T t)
        {
            return Derializable<T>(Serializble(t));
        }

    }
}

然后获得实例类的GetInstance函数里调用

这样输出的结果也就是深克隆要的效果了