原形模式 Prototype Pattern

一. 原型模式简介
　　 原型模式（Prototype Pattern）也是一种创建型模式，它关注的是大量相似对象的创建问题。我们经常会遇到这样的情况：在系统中要创建大量的对象，这些对象之间具有几乎完全相同的功能，只是在细节上有一点儿差别。
　　 这样的情形经常遇到。三国系列游戏是我最喜欢的游戏系列之一。你有没有注意到那里边上百位英雄的头像基本上很相似？你仔细区分就会发现，虽然每个人都不同，但基本上只具有几种脸型：长方的、圆形的、细长的，然后配上不同的胡子、眉毛、眼睛、嘴，有的再加点儿伤疤或装饰物（比如给独眼龙夏侯敦加个单眼罩），就成了不同的人物头像！那么，为什么会这样的？因为根据研究表明，人类的脸谱基本上只有有限的几个类型，只不过在细节和组合方面存在些许差异。游戏制作者具有依据这个理论，只对人脸进行有限的几种建模，然后再通过组合、修饰，就可以产生无数的头像了。
　　 用面向对象的方法来说就是，我们先建立一个原型，然后通过对原型进行复制和修饰的方法，就可以产生一个和原型相似的新对象。用GoF的话来说就是：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

        用OO来描述，我的　　　　

        　　　　　　　　

namespace  Prototype
{
     // 抽象钥匙原型
     public   abstract   class  Key
     {
         private   string  name;
 
         public   string  Name
         {
             get   {  return  name; }
             set   { name  =  value; }
        }
         private   string  owner;
 
         public   string  Owner
         {
             get   {  return  owner; }
             set   { owner  =  value; }
        }
         public  Key( string  name,  string  owner)
         {
             this .name  =  name;
             this .owner  =  owner;
        }
         // 钥匙复制自身的抽象定义
         public   abstract  Key Clone();
         public   override  String ToString()
         {
             return   this .Name  +   " , belongs to  "   +   this .Owner;
        }
    }
     // 大门钥匙
     public   class  GateKey : Key
     {
         public  GateKey( string  owner) :  base ( " Gate Key " , owner)  { }
 
         public   override  Key Clone()
         {
             return   new  GateKey( this .Owner);
        }
    }
     // 橱柜钥匙
     public   class  CabinetKey : Key
     {
         public  CabinetKey( string  owner) :  base ( " Cabinet Key " , owner)  { }
 
         public   override  Key Clone()
         {
             return   new  CabinetKey( this .Owner);
        }
    }
     // 客户调用方法
     public   class  Client
     {
         public   static   void  Main( string [] args)
         {
            Key oldGateKey, newGateKey, oldCabinetKey, newCabinetKey;
            oldGateKey  =   new  GateKey( " GF " );
            newGateKey  =  oldGateKey.Clone();
            newGateKey.Owner  =   " Me " ;
            oldCabinetKey  =   new  CabinetKey( " Me " );
            newCabinetKey  =  oldCabinetKey.Clone();
            newCabinetKey.Owner  =   " GF " ;
 
            Console.WriteLine(oldGateKey);
            Console.WriteLine(newGateKey);
            Console.WriteLine(oldCabinetKey);
            Console.WriteLine(newCabinetKey);
        }
    }
}

　　1. Clone()方法

　　2 . 深复制和浅复制

 

public   class  GateKey : Key
     {
         public  GateKey( string  owner) :  base ( " Gate Key " , owner)  { }

         public   override  Key Clone()
         {
             return  (Key) this .MemberwiseClone();
        }
    }

深复制是指逐个复制原型对象的内部变量，复制对象和原型对象各自具有单独的内存空间和生命周期。复制完成后，他们就是两个完全独立的个体，在逻辑上互不相干。本文实例中的Clone()操作都是深复制的实现。

　　3. 原型管理器

 

namespace  Prototype
{
     // 抽象钥匙原型
    [Serializable]
     public   abstract   class  Key : ICloneable
     {
         private   string  name;
 
         public   string  Name
         {
             get   {  return  name; }
             set   { name  =  value; }
        }
         private   string  owner;
 
         public   string  Owner
         {
             get   {  return  owner; }
             set   { owner  =  value; }
        }
         public  Key( string  name,  string  owner)
         {
             this .name  =  name;
             this .owner  =  owner;
        }
 
         public   override  String ToString()
         {
             return   this .Name  +   " , belongs to  "   +   this .Owner;
        }
 
         public   virtual  Object Clone()
         {
            MemoryStream memoryStream  =   new  MemoryStream();
            BinaryFormatter formatter  =   new  BinaryFormatter();
            formatter.Serialize(memoryStream,  this );
            memoryStream.Position  =   0 ;
             return  formatter.Deserialize(memoryStream);
        }
    }
     // 大门钥匙
    [Serializable]
     public   class  GateKey : Key
     {
         public  GateKey( string  owner) :  base ( " Gate Key " , owner)  { }
    }
     // 万能 钥匙 :-)
    [Serializable]
     public   class  GeneralKey : Key
     {
         public  GeneralKey( string  name,  string  owner) :  base (name, owner)  { }
    }
 
     public   class  KeyManager
     {
         private  System.Collections.Hashtable keys  =   new  System.Collections.Hashtable();
 
 
         public  Key  this [ string  name]
         {
             set   { keys.Add(name, value); }
             get   {  return  (Key)keys[name]; }
        }
    }
     // 客户调用方法
     public   class  Client
     {
         public   static   void  Main( string [] args)
         {
            KeyManager keyManager  =   new  KeyManager();
            keyManager[ " gate " ]  =   new  GateKey( " GF " );
            keyManager[ " key2 " ]  =   new  GeneralKey( " key2 " ,  " GF " );
            keyManager[ " key3 " ]  =   new  GeneralKey( " key3 " ,  " GF " );
            keyManager[ " key4 " ]  =   new  GeneralKey( " key4 " ,  " GF " );
            keyManager[ " key5 " ]  =   new  GeneralKey( " key5 " ,  " GF " );
 
            Key newKey  =  (Key)keyManager[ " key2 " ].Clone();
            newKey.Name  =   " Office " ;
            newKey.Owner  =   " Me " ;
 
            Console.WriteLine(newKey);
        }
    }
}

　　原型模式的一般结构如下：

• Prototype：抽象原型角色，定义一个原型的抽象定义，其中包含一个复制自身的接口。
• ConcretePrototypeA/B：具体原型角色，作为原型被复制的具体对象，需实现抽象原型所定义的接口。
• Client：客户调用端，客户使用原型对象复制出需要的对象

　　包含原型管理器的原型模式的结构如下：

• PrototypeManager：原型管理器角色，提供具体原型对象的增加、删除、浏览等管理功能。

• 当要实例化的类是在运行时刻指定时，例如，通过动态装载；
• 为了避免创建一个与产品类层次平行的工厂类层次时；
• 当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。