23种设计模式之原型模式（Prototype Pattern）

原型模式

使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象

分析：

孙悟空：根据自己的形状复制（克隆）出多个身外身

软件开发：通过复制一个原型对象得到多个与原型对象一模一样的新对象

 

工作原理：将一个原型对象传给要发动创建的对象（即客户端对象），这个要发动创建的对象通过请求原型对象复制自己来实现创建过程

创建新对象（也称为克隆对象）的工厂就是原型类自身，工厂方法由负责复制原型对象的克隆方法来实现

通过克隆方法所创建的对象是全新的对象，它们在内存中拥有新的地址，每一个克隆对象都是独立的

通过不同的方式对克隆对象进行修改以后，可以得到一系列相似但不完全相同的对象

 

原型模式的结构

原型模式包含以下3个角色：

•Prototype（抽象原型类）

•ConcretePrototype（具体原型类）

•Client（客户类）

 

浅克隆与深克隆

浅克隆(Shallow Clone)：当原型对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制

深克隆(Deep Clone)：除了对象本身被复制外，对象所包含的所有成员变量也将被复制

    /// <summary>
    /// 原型模式：单例的基础上升级了一下，把对象从内存层面复制了一下，然后返回
    ///    是个新对象，但是又不是new出来的
    /// </summary>
    [Serializable] 
    public class Prototype
    {
        /// <summary>
        /// 构造函数耗时耗资源
        /// </summary>
        private Prototype()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(2000);
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }
        /// <summary>
        /// 3 全局唯一静态  重用这个变量
        /// </summary>
        private static volatile Prototype _Prototype = new Prototype()
        {
            CurrentEmployee = "admin",
            Member = new Member { Id=1,Name="aaa"}
        };
        /// <summary>
        /// 2 公开的静态方法提供对象实例
        /// </summary>
        /// <returns></returns>
        public static Prototype CreateInstance()
        {
            Prototype prototype = (Prototype)_Prototype.MemberwiseClone();
            return prototype;
        }
        public static Prototype DeepClone()
        {
            Prototype prototype = JsonConvert.DeserializeObject<Prototype>(JsonConvert.SerializeObject(_Prototype));
            return prototype;
        }
        public Member Member { get; set; }
        public string CurrentEmployee { get; set; }
    }
    [Serializable] 
    public class Member
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

前端调用

                {//浅拷贝
                    Prototype prototype1 = Prototype.CreateInstance();
                    Prototype prototype2 = Prototype.CreateInstance();
                    prototype1.CurrentEmployee = "prototype1";
                    prototype1.Member.Id = 2;
                    prototype1.Member.Name = "bbb";
                    prototype2.CurrentEmployee = "prototype2";
                    prototype2.Member.Id = 3;
                    prototype2.Member.Name = "ccc";
                    Console.WriteLine(prototype1.CurrentEmployee);
                    Console.WriteLine(prototype1.Member.Id);
                    Console.WriteLine(prototype1.Member.Name);
                    Console.WriteLine(prototype2.CurrentEmployee);
                    Console.WriteLine(prototype2.Member.Id);
                    Console.WriteLine(prototype2.Member.Name);
                }
                {//深拷贝
                    Prototype prototype1 = Prototype.DeepClone();
                    Prototype prototype2 = Prototype.DeepClone();
                    prototype1.CurrentEmployee = "prototype1";
                    prototype1.Member.Id = 2;
                    prototype1.Member.Name = "bbb";
                    prototype2.CurrentEmployee = "prototype2";
                    prototype2.Member.Id = 3;
                    prototype2.Member.Name = "ccc";
                    Console.WriteLine(prototype1.CurrentEmployee);
                    Console.WriteLine(prototype1.Member.Id);
                    Console.WriteLine(prototype1.Member.Name);
                    Console.WriteLine(prototype2.CurrentEmployee);
                    Console.WriteLine(prototype2.Member.Id);
                    Console.WriteLine(prototype2.Member.Name);
                }

执行结果

深度拷贝就是利用序列化与反序列化创建对象，这种方法好像也走构造函数，那么还不如直接new 就失去了原型模式的意义了

本文参考文档：https://www.cnblogs.com/genesis/p/6097528.html