原型模式（Prototype Pattern）

概述

在软件系统中，有时候面临的产品类是动态变化的，并且这个产品类具备必定的等级结构。这时若是用工厂模式，则与产品类等级结构平行的工厂方法类也要随着这种变化而变化，显然不大合适。那么如何封装这种动态的变化？从而使依赖于这些易变对象的客户程序不随着产品类变化？

意图

用原型实例指定建立对象的种类，而且经过拷贝这些原型建立新的对象。

结构图

 

Prototype模式结构图

生活中的例子

Prototype模式使用原型实例指定建立对象的种类。新产品的原型一般是先于所有产品创建的，这样的原型是被动的，并不参与复制它本身。一个细胞的有丝分裂，产生两个一样的细胞，是一个扮演主动角色复制本身原型的例子，这演示了原型模式。一个细胞分裂，产生两个一样基因型的细胞。换句话说，细胞克隆了本身。

 

使用细胞分裂例子的Prototype模式对象图

原型模式解说

咱们考虑这样一个场景，假定咱们要开发一个调色板，用户单击调色板上任一个方块，将会返回一个对应的颜色的实例，下面咱们看看如何经过原型模式来达到系统动态加载具体产品的目的。

很天然，咱们利用OO的思想，把每一种颜色做为一个对象，并为他们抽象出一个公用的父类，以下图：

 

实现代码：

public abstract class Color

{

        public abstract void Display();

}

public class RedColor:Color

{

    public override void Display()

    {

        Console.WriteLine("Red's RGB Values are:255,0,0");

    }

}

public class GreenColor:Color

{

    public override void Display()

    {

        Console.WriteLine("Green's RGB Values are:0,255,0");

    }

}

客户程序须要某一种颜色的时候，只须要建立对应的具体类的实例就能够了。可是这样咱们并无达到封装变化点的目的，也许你会说，可使用工厂方法模式，为每个具体子类定义一个与其等级平行的工厂类，那么好，看一下实现：

 

实现代码：

public abstract class ColorFactory

{

    public abstract Color Create();

}

public class RedFactory:ColorFactory

{

    public override Color Create()

    {

        return new RedColor();

    }

}

public class GreenFactory:ColorFactory

{

    public override Color Create()

    {

        return new GreenColor();

    }

}

实现了这一步以后，能够看到，客户程序只要调用工厂方法就能够了。彷佛咱们用工厂方法模式来解决是没有问题的。可是，咱们考虑的仅仅是封装了new变化，而没有考虑颜色的数量是不断变化的，甚至多是在程序运行的过程当中动态增长和减小的，那么用这种方法实现，随着颜色数量的不断增长，子类的数量会迅速膨大，致使子类过多，显然用工厂方法模式有些不大合适。

进一步思考，这些Color子类仅仅在初始化的颜色对象类别上有所不一样。添加一个ColorTool这样的类，来参数化的它的实例，而这些实例是由Color支持和建立的。咱们让ColorTool经过克隆或者拷贝一个Color子类的实例来建立新的Color，这个实例就是一个原型。以下图所示：

 

实现代码：

abstract class ColorPrototype

{

    public abstract ColorPrototype Clone();

}

 

class ConcteteColorPrototype : ColorPrototype

{

 

    private int _red, _green, _blue;

 

 

    public ConcteteColorPrototype(int red, int green, int blue)

    {

        this._red = red;

        this._green = green;

        this._blue = blue;

    }

     public override ColorPrototype Clone()

    {

        //实现浅拷贝

        return (ColorPrototype) this.MemberwiseClone();

    }

 

    public void Display(string _colorname)

    {

        Console.WriteLine("{0}'s RGB Values are: {1},{2},{3}",

            _colorname,_red, _green, _blue );

    }

}

 

class ColorManager

{ 

    Hashtable colors = new Hashtable();

 

 

    public ColorPrototype this[string name]

    {

        get

        {

            return (ColorPrototype)colors[name];

        }

        set

        {

            colors.Add(name,value);

        }

    }

}

如今咱们分析一下，这样带来了什么好处？首先从子类的数目上大大减小了，不须要再为每一种具体的颜色产品而定一个类和与它等级平行的工厂方法类，而ColorTool则扮演了原型管理器的角色。再看一下为客户程序的实现：

class App

{

    public static void Main(string[] args)

    {

        ColorManager colormanager = new ColorManager();

 

        //初始化颜色

        colormanager["red"] = new ConcteteColorPrototype(255, 0, 0);

        colormanager["green"] = new ConcteteColorPrototype(0, 255, 0);

        colormanager["blue"] = new ConcteteColorPrototype(0, 0, 255);

        colormanager["angry"] = new ConcteteColorPrototype(255, 54, 0);

        colormanager["peace"] = new ConcteteColorPrototype(128, 211, 128);

        colormanager["flame"] = new ConcteteColorPrototype(211, 34, 20);

 

        //使用颜色

        string colorName = "red";

        ConcteteColorPrototype c1 = (ConcteteColorPrototype)colormanager[colorName].Clone();

        c1.Display(colorName);

 

        colorName = "peace";

        ConcteteColorPrototype c2 = (ConcteteColorPrototype)colormanager[colorName].Clone();

        c2.Display(colorName);

 

        colorName = "flame";

        ConcteteColorPrototype c3 = (ConcteteColorPrototype)colormanager[colorName].Clone();

        c3.Display(colorName);

 

        Console.ReadLine();

    }

}

能够看到，客户程序经过注册原型实例就能够将一个具体产品类并入到系统中，在运行时刻，能够动态的创建和删除原型。最后还要注意一点，在上面的例子中，用的是浅表复制。若是想作深复制，须要经过序列化的方式来实现。通过了上面的分析以后，咱们再来思考下面的问题：

1．为何须要Prototype模式？

引入原型模式的本质在于利用已有的一个原型对象，快速的生成和原型对象同样的实例。你有一个A的实例a:A a = new A();如今你想生成和car1同样的一个实例b，按照原型模式，应该是这样：A b = a.Clone();而不是从新再new一个A对象。经过上面这句话就能够获得一个和a同样的实例，确切的说，应该是它们的数据成员是同样的。Prototype模式一样是返回了一个A对象而没有使用new操做。

2．引入Prototype模式带来了什么好处？

能够看到，引入Prototype模式后咱们再也不须要一个与具体产品等级结构平行的工厂方法类，减小了类的构造，同时客户程序能够在运行时刻创建和删除原型。

3．Prototype模式知足了哪些面向对象的设计原则？

依赖倒置原则：上面的例子，原型管理器（ColorManager）仅仅依赖于抽象部分（ColorPrototype），而具体实现细节（ConcteteColorPrototype）则依赖与抽象部分（ColorPrototype），因此Prototype很好的知足了依赖倒置原则。

 

经过序列化实现深拷贝

要实现深拷贝，能够经过序列化的方式。抽象类及具体类都必须标注为可序列化的[Serializable]，上面的例子加上深拷贝以后的完整程序以下：

using System;

using System.Collections;

using System.IO;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

 

[Serializable]

abstract class ColorPrototype

{

    public abstract ColorPrototype Clone(bool Deep);

}

 

[Serializable]

class ConcteteColorPrototype : ColorPrototype

{

 

    private int _red, _green, _blue;

 

 

    public ConcteteColorPrototype(int red, int green, int blue)

    {

        this._red = red;

        this._green = green;

        this._blue = blue;

    }

     public override ColorPrototype Clone(bool Deep)

    {

        if(Deep)

            return CreateDeepCopy();

        else

            return (ColorPrototype) this.MemberwiseClone();

    }

 

    //实现深拷贝

    public ColorPrototype CreateDeepCopy()

    {

        ColorPrototype colorPrototype;

 

        MemoryStream memoryStream = new MemoryStream();

        BinaryFormatter formatter = new BinaryFormatter();

 

        formatter.Serialize(memoryStream, this);

        memoryStream.Position = 0;

 

        colorPrototype = (ColorPrototype)formatter.Deserialize(memoryStream);

        return colorPrototype;

    }

 

    public ConcteteColorPrototype Create(int red,int green,int blue)

    {

        return new ConcteteColorPrototype(red,green,blue); 

    }

 

    public void Display(string _colorname)

    {

        Console.WriteLine("{0}'s RGB Values are: {1},{2},{3}",

            _colorname,_red, _green, _blue );

    }

}

 

class ColorManager

{ 

    Hashtable colors = new Hashtable();

     public ColorPrototype this[string name]

    {

        get

        {

            return (ColorPrototype)colors[name];

        }

        set

        {

            colors.Add(name,value);

        }

    }

}

 

 

class App

{

    public static void Main(string[] args)

    {

        ColorManager colormanager = new ColorManager();

 

        //初始化颜色

        colormanager["red"] = new ConcteteColorPrototype(255, 0, 0);

        colormanager["green"] = new ConcteteColorPrototype(0, 255, 0);

        colormanager["blue"] = new ConcteteColorPrototype(0, 0, 255);

        colormanager["angry"] = new ConcteteColorPrototype(255, 54, 0);

        colormanager["peace"] = new ConcteteColorPrototype(128, 211, 128);

        colormanager["flame"] = new ConcteteColorPrototype(211, 34, 20);

 

        //使用颜色

        string colorName = "red";

        ConcteteColorPrototype c1 = (ConcteteColorPrototype)colormanager[colorName].Clone(false);

        c1.Display(colorName);

 

        colorName = "peace";

        ConcteteColorPrototype c2 = (ConcteteColorPrototype)colormanager[colorName].Clone(true);

        c2.Display(colorName);

 

        colorName = "flame";

        ConcteteColorPrototype c3 = (ConcteteColorPrototype)colormanager[colorName].Clone(true);

        c3.Display(colorName);

 

        Console.ReadLine();

    }

}

 

实现要点

1．使用原型管理器，体如今一个系统中原型数目不固定时，能够动态的建立和销毁，如上面的举的调色板的例子。

2．实现克隆操做，在.NET中可使用Object类的MemberwiseClone()方法来实现对象的浅表拷贝或经过序列化的方式来实现深拷贝。

3．Prototype模式一样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它一样要求这些“易变类”拥有稳定的接口。

效果

1．它对客户隐藏了具体的产品类，所以减小了客户知道的名字的数目。

2．Prototype模式容许客户只经过注册原型实例就能够将一个具体产品类并入到系统中，客户能够在运行时刻创建和删除原型。

3．减小了子类构造，Prototype模式是克隆一个原型而不是请求工厂方法建立一个，因此它不须要一个与具体产品类平行的Creater类层次。

4．Portotype模式具备给一个应用软件动态加载新功能的能力。因为Prototype的独立性较高，能够很容易动态加载新功能而不影响老系统。

5．产品类不须要非得有任何事先肯定的等级结构，由于Prototype模式适用于任何的等级结构

6．Prototype模式的最主要缺点就是每个类必须配备一个克隆方法。并且这个克隆方法须要对类的功能进行通盘考虑，这对全新的类来讲不是很难，但对已有的类进行改造时，不必定是件容易的事。

适用性

在下列状况下，应当使用Prototype模式：

1．当一个系统应该独立于它的产品建立，构成和表示时；

2．当要实例化的类是在运行时刻指定时，例如，经过动态装载；

3．为了不建立一个与产品类层次平行的工厂类层次时；

4．当一个类的实例只能有几个不一样状态组合中的一种时。创建相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

总结

Prototype模式同工厂模式，一样对客户隐藏了对象的建立工做，可是，与经过对一个类进行实例化来构造新对象不一样的是，原型模式是经过拷贝一个现有对象生成新对象的，达到了“隔离类对象的使用者和具体类型（易变类）之间的耦合关系”的目的。