文章详情

  • 游戏榜单
  • 软件榜单
关闭导航
热搜榜
热门下载
热门标签
php爱好者> php文档>.NET设计模式(6):原型模式(Prototype Pattern)

.NET设计模式(6):原型模式(Prototype Pattern)

时间:2010-09-17  来源:山天大畜

原型模式(Prototype Pattern)

——.NET设计模式系列之六

概述

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

原型模式的用意是:通过给出一个原型对象来指明所要创建的对象类型,然后用复制这个原型对象的办法创建出更多的同类型对象。

意图

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

结构图

 

Prototype模式结构图

  • 客户(Client)角色:客户类提出创建对象的请求。
    抽象原型(Prototype)角色:这是一个抽象角色,通常由一个C#接口或抽象类实现。此角色给出所有的具体原型类所需的接口。在C#中,抽象原型角色通常实现了ICloneable接口。
    具体原型(Concrete Prototype)角色:被复制的对象。此角色需要实现抽象原型角色所要求的接口。

生活中的例子

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

 

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

孙悟空在与黄风怪的战斗中,"使一个身外身的手段:把毫毛揪下一把,用口嚼得粉碎,望上一喷,叫声'变',变有百十个行者,都是一样得打扮,各执一根铁棒,把那怪围在空中。"换而言之,孙悟空可以根据自己的形象,复制出很多"身外身"来。

老孙这种身外身的手段在面向对象设计领域里叫原型(Prototype)模式。

C#对原型模式的支持

在C#里面,我们可以很容易的通过Clone()方法实现原型模式。任何类,只要想支持克隆,必须实现C#中的ICloneable接口。ICloneable接口中有一Clone方法,可以在类中复写实现自定义的克隆方法。克隆的实现方法有两种:浅拷贝(shallow copy)与深拷贝(deep copy)。

(以下摘自:《.NET框架程序设计(修订版)》,李建忠译)浅拷贝是指当对象的字段值被拷贝时,字段引用的对象不会被拷贝。例如,如果一个对象有一个指向字符串的字段,并且我们对该对象做了一个浅拷贝,那么两个对象将引用同一个字符串。而深拷贝是对对象实例中字段引用的对象也进行拷贝的一种方式,所以如果一个对象有一个指向字符串的字段,并且我们对该对象做了一个深拷贝的话,我们将创建一个新的对象和一个新的字符串--新对象将引用新字符串。需要注意的是执行深拷贝后,原来的对象和新创建的对象不会共享任何东西;改变一个对象对另外一个对象没有任何影响。

原型模式解说

下面的程序给出了一个示意性的实现:

Prototype // Prototype pattern -- Structural example   
using System; 

// "Prototype" 
abstract class Prototype
{
    // Fields 
    private string id;

    // Constructors 
    public Prototype(string id)
    {
        this.id = id;
    }

    public string Id
    {
        get { return id; }
    }

    // Methods 
    abstract public Prototype Clone();
}

// "ConcretePrototype1" 
class ConcretePrototype1 : Prototype
{
    // Constructors 
    public ConcretePrototype1(string id) : base(id) { }

    // Methods 
    override public Prototype Clone()
    {
        // Shallow copy 
        return (Prototype)this.MemberwiseClone();
    }
}

// "ConcretePrototype2" 
class ConcretePrototype2 : Prototype
{
    // Constructors 
    public ConcretePrototype2(string id) : base(id) { }

    // Methods 
    override public Prototype Clone()
    {
        // Shallow copy 
        return (Prototype)this.MemberwiseClone();
    }
}

/// <summary> 
/// Client test 
/// </summary> 
class Client
{
    public static void Main(string[] args)
    {
        // Create two instances and clone each 
        ConcretePrototype1 p1 = new ConcretePrototype1("I");
        ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();
        Console.WriteLine("Cloned: {0}", c1.Id);

        ConcretePrototype2 p2 = new ConcretePrototype2("II");
        ConcretePrototype2 c2 = (ConcretePrototype2)p2.Clone();
        Console.WriteLine("Cloned: {0}", c2.Id);
    }
}

 

这个例子实现了一个浅拷贝。其中MemberwiseClone()方法是Object类的一个受保护方法,实现了对象的浅拷贝。如果希望实现一个深拷贝,应该实现ICloneable接口,并自己编写ICloneable的Clone接口方法。


带Prototype Manager的原型模式

原型模式的第二种形式是带原型管理器的原型模式,其UML图如下:

 

客户(Client)角色:客户端类向原型管理器提出创建对象的请求。
抽象原型(Prototype)角色:这是一个抽象角色,通常由一个C#接口或抽象类实现。此角色给出所有的具体原型类所需的接口。在C#中,抽象原型角色通常实现了ICloneable接口。
具体原型(Concrete Prototype)角色:被复制的对象。此角色需要实现抽象的原型角色所要求的接口。
原型管理器(Prototype Manager)角色:创建具体原型类的对象,并记录每一个被创建的对象。

下面这个例子演示了在原型管理器中存储用户预先定义的颜色原型,客户通过原型管理器克隆颜色对象。

ColorPrototype // Prototype pattern -- Real World example   
using System; 
using System.Collections; 

// "Prototype" 
abstract class ColorPrototype
{
    // Methods 
    public abstract ColorPrototype Clone();
}

// "ConcretePrototype" 
class Color : ColorPrototype
{
    // Fields 
    private int red, green, blue;

    // Constructors 
    public Color(int red, int green, int blue)
    {
        this.red = red;
        this.green = green;
        this.blue = blue;
    }

    // Methods 
    public override ColorPrototype Clone()
    {
        // Creates a 'shallow copy' 
        return (ColorPrototype)this.MemberwiseClone();
    }

    public void Display()
    {
        Console.WriteLine("RGB values are: {0},{1},{2}",
          red, green, blue);
    }
}

// Prototype manager 
class ColorManager
{
    // Fields 
    Hashtable colors = new Hashtable();

    // Indexers 
    public ColorPrototype this[string name]
    {
        get { return (ColorPrototype)colors[name]; }
        set { colors.Add(name, value); }
    }
}

/// <summary> 
///  PrototypeApp test 
/// </summary> 
class PrototypeApp
{
    public static void Main(string[] args)
    {
        ColorManager colormanager = new ColorManager();

        // Initialize with standard colors 
        colormanager["red"] = new Color(255, 0, 0);
        colormanager["green"] = new Color(0, 255, 0);
        colormanager["blue"] = new Color(0, 0, 255);

        // User adds personalized colors 
        colormanager["angry"] = new Color(255, 54, 0);
        colormanager["peace"] = new Color(128, 211, 128);
        colormanager["flame"] = new Color(211, 34, 20);

        // User uses selected colors 
        string colorName = "red";
        Color c1 = (Color)colormanager[colorName].Clone();
        c1.Display();

        colorName = "peace";
        Color c2 = (Color)colormanager[colorName].Clone();
        c2.Display();

        colorName = "flame";
        Color c3 = (Color)colormanager[colorName].Clone();
        c3.Display();
    }
}


浅拷贝与深拷贝

下面给出浅拷贝与深拷贝的两个例子,例子使用了ICloneable接口。C#中的数组是引用型的变量,我们通过数组来进行演示:

浅拷贝:

浅拷贝 using System; 

class ShallowCopy : ICloneable
{
    public int[] v = { 1, 2, 3 };

    public Object Clone()
    {
        return this.MemberwiseClone();
    }

    public void Display()
    {
        foreach (int i in v)
            Console.Write(i + ", ");
        Console.WriteLine();
    }
}

class Client
{
    public static void Main()
    {
        ShallowCopy sc1 = new ShallowCopy();
        ShallowCopy sc2 = (ShallowCopy)sc1.Clone();
        sc1.v[0] = 9;

        sc1.Display();
        sc2.Display();
    }
}

 

ShallowCopy对象实现了一个浅拷贝,因此当对sc1进行克隆时,其字段v并没有克隆,这导致sc1与sc2的字段v都指向了同一个v,因此,当修改了sc1的v[0]后,sc2的v[0]也发生了变化。

深拷贝:

深拷贝 using System; 

class DeepCopy : ICloneable
{
    public int[] v = { 1, 2, 3 };

    // 默认构造函数 
    public DeepCopy()
    {
    }

    // 供Clone方法调用的私有构造函数 
    private DeepCopy(int[] v)
    {
        this.v = (int[])v.Clone();
    }

    public Object Clone()
    {
        // 构造一个新的DeepCopy对象,构造参数为 
        // 原有对象中使用的 v  
        return new DeepCopy(this.v);
    }

    public void Display()
    {
        foreach (int i in v)
            Console.Write(i + ", ");
        Console.WriteLine();
    }
}

class Client
{
    public static void Main()
    {
        DeepCopy dc1 = new DeepCopy();
        DeepCopy dc2 = (DeepCopy)dc1.Clone();
        dc1.v[0] = 9;

        dc1.Display();
        dc2.Display();
    }
}

 

这次在克隆的时候,不但克隆对象本身,连里面的数组字段一并克隆。因此,最终打印出来的dc1与dc2不同。

[--摘自吕震宇]

 

通过序列化实现深拷贝

要实现深拷贝,可以通过序列化的方式。抽象类及具体类都必须标注为可序列化的[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模式的优点

1.Prototype模式允许动态增加或减少产品类。由于创建产品类实例的方法是产批类内部具有的,因此增加新产品对整个结构没有影响。
2.Prototype模式提供了简化的创建结构。工厂方法模式常常需要有一个与产品类等级结构相同的等级结构,而Prototype模式就不需要这样。
3.Portotype模式具有给一个应用软件动态加载新功能的能力。由于Prototype的独立性较高,可以很容易动态加载新功能而不影响老系统。
4.产品类不需要非得有任何事先确定的等级结构,因为Prototype模式适用于任何的等级结构。

Prototype模式的缺点

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

总结

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

[--摘自TerryLee]

相关阅读 更多 +
排行榜 更多 +
辰域智控app

辰域智控app

系统工具 下载
网医联盟app

网医联盟app

运动健身 下载
汇丰汇选App

汇丰汇选App

金融理财 下载