设计模式之-原型模式

原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节。工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

接下来我们就以简历为例，当我们要面试时，通常会通过打印机将简历一份份打印出来。

简历代码初步实现

简历类：

namespace PrototypePattern
{
    /// <summary>
    /// 简历
    /// </summary>
    public class Resume
    {
        public string Name { get; set; }
        public string Sex { get; set; }
        public int Age { get; set; }
        public string TimeArea { get; set; }
        public string Company { get; set; }
        public Resume(string name)
        {
            this.Name = name;
        }
        //设置个人信息
        public void SetPersonalInfo(string sex, int age)
        {
            this.Sex = sex;
            this.Age = age;
        }
        //设置工作经历
        public void SetWorkExperience(string timeArea, string company)
        {
            this.TimeArea = timeArea;
            this.Company = company;
        }
        //显示
        public void Show()
        {
            Console.WriteLine($"姓名：{this.Name} 性别：{this.Sex} 年龄：{this.Age}");
            Console.WriteLine($"工作经历：{this.TimeArea} {this.Company}");
        }
    }
}

客户端调用代码：

static void Main(string[] args)
{
    try
    {
        Resume a = new Resume("tom");
        a.SetPersonalInfo("男", 21);
        a.SetWorkExperience("1998-2000", "XXX公司");

        Resume b = new Resume("tom");
        b.SetPersonalInfo("男", 21);
        b.SetWorkExperience("1998-2000", "XXX公司");

        Resume c = new Resume("tom");
        c.SetPersonalInfo("男", 21);
        c.SetWorkExperience("1998-2000", "XXX公司");

        a.Show();
        b.Show();
        c.Show();
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
    Console.ReadKey();
}

结果如下：

没毛病，出现了3张一模一模的简历。在这里我们需要3张简历，所以我们实例化了3次。但我觉得这样的客户端很麻烦，如果需要20份，200份呢，我们难道需要实例化20次、200次？

如果简历中写错了一个字，把1998错写成了1999,这时我们就需要修改20，200次。。。

 Oh My God,这实在是太糟糕了。

这时有人会说，我们可以这样写：

Resume a = new Resume("tom");
a.SetPersonalInfo("男", 21);
a.SetWorkExperience("1998-2000", "XXX公司");

Resume b = a;
Resume c = a;

a.Show();
b.Show();
c.Show();

这样确实可以实现和上面一样的效果，但这只是“传递引用”，并不是传值，这样就相当于在b纸张和c纸张上写着简历在a纸张上一样。

现在我想让这个简历其它的全部一样，就工作经历不同，怎么办？上面的操作是“传递引用”，当我们修改一个简历的工作经历时候，其它的简历也会跟随着改变。

原型模式

原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式其实就是从一个对象再创建一个可定制的对象，而且不需要知道任何的细节。

原型类：

namespace PrototypePattern.PrototypePattern
{
    abstract class Prototype
    {
        public int Id { get; set; }
        public Prototype(int id)
        {
            this.Id = id;
        }

        public abstract Prototype Clone();//这个抽象类的关键就是这个Clone方法
    }
}

具体原型类：

namespace PrototypePattern.PrototypePattern
{
    /// <summary>
    /// 具体原型
    /// </summary>
    class ConcretePrototype1 : Prototype
    {
        public ConcretePrototype1(int id) : base(id)
        {

        }
        /// <summary>
        /// 创建当前对象的浅表副本。
        /// 方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。
        /// 如果字段是值类型的，则对该字段进行逐位复制。
        /// 如果字段是引用类型的，则复制引用，但不复制引用的对象，因此，原始对象及其副本引用同一个对象
        /// </summary>
        /// <returns></returns>
        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }
    }
}

客户端代码：

ConcretePrototype1 p1 = new ConcretePrototype1(1);
ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();

Console.WriteLine($"p1.Id={p1.Id},c1.Id={c1.Id}");
c1.Id = 2;
Console.WriteLine($"p1.Id={p1.Id},c1.Id={c1.Id}");

结果如下：

对于.net而言，原型抽象类Prototype类是用不类的，因为克隆实在是太常用了，所以.net在System命名空间中提供了ICloneable接口，其中就只有唯一的一个方法Clone(),这样我们就可以只需要实现这个接口就可以完成原型模式了。

简历的原型实现

 简历类：

namespace PrototypePattern
{
    /// <summary>
    /// 简历
    /// </summary>
    public class Resume : ICloneable
    {
        public string Name { get; set; }
        public string Sex { get; set; }
        public int Age { get; set; }
        public string TimeArea { get; set; }
        public string Company { get; set; }
        public Resume(string name)
        {
            this.Name = name;
        }
        //设置个人信息
        public void SetPersonalInfo(string sex, int age)
        {
            this.Sex = sex;
            this.Age = age;
        }
        //设置工作经历
        public void SetWorkExperience(string timeArea, string company)
        {
            this.TimeArea = timeArea;
            this.Company = company;
        }
        //显示
        public void Show()
        {
            Console.WriteLine($"姓名：{this.Name} 性别：{this.Sex} 年龄：{this.Age}");
            Console.WriteLine($"工作经历：{this.TimeArea} {this.Company}");
        }

        public object Clone()
        {
            return (Resume)this.MemberwiseClone();
        }
    }
}

客户端调用代码：

Resume a = new Resume("tom");
a.SetPersonalInfo("男", 21);
a.SetWorkExperience("1998-2000", "XXX公司");

Resume b = (Resume)a.Clone();
b.SetWorkExperience("2000-2002", "YYY公司");

Resume c = (Resume)a.Clone();
c.SetWorkExperience("2002-2004", "ZZZ公司");

a.Show();
b.Show();
c.Show();

结果如下：

这样实现好多了，而且当你想要改其中某一份简历的时候，直接修改就好了，并不会影响到其它的简历。

一般在初始化信息不发生变化的情况下，克隆是最好的方法。这既隐藏了对象创建的细节，又提高了性能，何乐而不为呢？

浅拷贝与深拷贝

当你自以为完美的时候，然后结果却往往令你大失所望。

哈哈，没错，现在简历对象的所有属性都是值类型或者重写过运算符的引用类型。那么当你的简历类中含有“引用类型”时，那么当你克隆简历时，这个引用类型会不会也被克隆过来呢？

我们简历类中有一个“设置工作经历”的方法，在实际开发中，都会有一个工作经历类，现在我们添加一个“工作经历”类， 当中有“时间区间”和“公司名称”属性，类直接调用这个对象即可。

工作经历类：

namespace PrototypePattern
{
    public class WorkExperience
    {
        public string WorkDate { get; set; }
        public string Company { get; set; }
    }
}

简历类：

namespace PrototypePattern
{
    /// <summary>
    /// 简历
    /// </summary>
    public class Resume : ICloneable
    {
        public string Name { get; set; }
        public string Sex { get; set; }
        public int Age { get; set; }
        public WorkExperience WorkExperience { get; set; }
        public Resume(string name)
        {
            this.Name = name;
            this.WorkExperience = new WorkExperience();
        }
        //设置个人信息
        public void SetPersonalInfo(string sex, int age)
        {
            this.Sex = sex;
            this.Age = age;
        }
        //设置工作经历
        public void SetWorkExperience(string timeArea, string company)
        {
            WorkExperience.WorkDate = timeArea;
            WorkExperience.Company = company;
        }
        //显示
        public void Show()
        {
            Console.WriteLine($"姓名：{this.Name} 性别：{this.Sex} 年龄：{this.Age}");
            Console.WriteLine($"工作经历：{this.WorkExperience.WorkDate} {this.WorkExperience.Company}");
        }
        public object Clone()
        {
            return (Resume)this.MemberwiseClone();
        }
    }
}

客户端代码调用：

    Resume a = new Resume("tom");
    a.SetPersonalInfo("男", 21);
    a.SetWorkExperience("1998-2000", "XXX公司");

    Resume b = (Resume)a.Clone();
    b.SetWorkExperience("2000-2002", "YYY公司");

    Resume c = (Resume)a.Clone();
    c.SetWorkExperience("2002-2004", "ZZZ公司");

    a.Show();
    b.Show();
    c.Show();

如果如下：

由于MemberwiseClone()方法是浅表拷贝，对于值类型没啥问题，但对于引用类型，就只复制了引用，它们所指向的任是一个对象。那么怎么实现拷贝时，要将简历类当中的引用类型的对象拷贝一份，而不是拷贝引用呢？

简历的深复制实现

工作经历类：

namespace PrototypePattern
{
    public class WorkExperience:ICloneable
    {
        public string WorkDate { get; set; }
        public string Company { get; set; }

        public object Clone()
        {
            return (WorkExperience)this.MemberwiseClone();
        }
    }
}

简历类：

namespace PrototypePattern
{
    /// <summary>
    /// 简历
    /// </summary>
    public class Resume : ICloneable
    {
        public string Name { get; set; }
        public string Sex { get; set; }
        public int Age { get; set; }
        public WorkExperience WorkExperience { get; set; }
        public Resume(string name)
        {
            this.Name = name;
            this.WorkExperience = new WorkExperience();
        }
        public Resume(WorkExperience work)
        {
            this.WorkExperience = (WorkExperience)work.Clone();
        }
        //设置个人信息
        public void SetPersonalInfo(string sex, int age)
        {
            this.Sex = sex;
            this.Age = age;
        }
        //设置工作经历
        public void SetWorkExperience(string timeArea, string company)
        {
            WorkExperience.WorkDate = timeArea;
            WorkExperience.Company = company;
        }
        //显示
        public void Show()
        {
            Console.WriteLine($"姓名：{this.Name} 性别：{this.Sex} 年龄：{this.Age}");
            Console.WriteLine($"工作经历：{this.WorkExperience.WorkDate} {this.WorkExperience.Company}");
        }
        public object Clone()
        {
            Resume obj = new Resume(this.WorkExperience);
            obj.Name = this.Name;
            obj.Sex = this.Sex;
            obj.Age = this.Age;
            return obj;
        }
    }
}

客户端调用：

    Resume a = new Resume("tom");
    a.SetPersonalInfo("男", 21);
    a.SetWorkExperience("1998-2000", "XXX公司");

    Resume b = (Resume)a.Clone();
    b.SetWorkExperience("2000-2002", "YYY公司");

    Resume c = (Resume)a.Clone();
    c.SetWorkExperience("2002-2004", "ZZZ公司");

    a.Show();
    b.Show();
    c.Show();

 结果如下：

注意：使用实现ICloneable接口来实现原型模式的深拷贝，如果类与类之前的关系比较简单的话还好，如果很复杂的话，通常会让你很头痛，这个可以推荐一个简单的方法。就是使用二进制序列化将要拷贝的对象(简历)先序列化，然后再反序列化成对象，这个简历当中的引用类型的属性就能实现深拷贝了。

由于在一些特定的场合，会经常涉及到深拷贝或浅拷贝，比如说，数据集对象DataSet,它就有Clone()方法和Copy()方法，Clone()方法用来复制DataSet的结构，但不复制DataSet的数据 ，实现了原型模式的浅拷贝。Copy()方法不但复制结构 ，也复制数据，其实就是实现了原型模式的深拷贝。

源代码地址：https://github.com/houzhenhuang/DesignPattern