1、概述
在软件系统中，有时候面临的产品类是动态变化的，而且这个产品类具有一定的等级结构。这时如果用工厂模式，则与产品类等级结构平行的工厂方法类也要随着这种变化而变化，显然不大合适。那么如何封装这种动态的变化？从而使依赖于这些易变对象的客户程序不随着产品类变化？
2、意图
原型模式是通过现有的一个对象，复制出更多的此类型的对象以供使用。
3、结构图
图解说明
UsePrototype类是用户类也是程序启动类
RGBColor类是一个颜色类
ColorPrototype类是抽象类，含有Clone方法
ConcretePrototype 类继承ColorPrototype，实现浅拷贝。
ConcretePrototypeDeep类继承ColorPrototype，实现深拷贝
关于深拷贝和浅拷贝简单的说：
浅拷贝(Shallow Copy影子克隆)：只复制对象的基本类型。对象类型,仍属于原来的引用。
深拷贝(Deep Copy 深度克隆)：不仅复制对象的基本类,同时也复制原对象中的对象.完全产生新对象。
4、代码的实现
注意：代码中的深拷贝是使用序列化实现的。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
namespace PrototypePattern
{
[Serializable]
public abstract class ColorPrototype
{
public abstract ColorPrototype Clone();
}
[Serializable]
public class RGBColor
{
/// <summary>
/// 颜色的三色素：红、绿、兰
/// </summary>
private int _red,_green,_blue;
public RGBColor(int red, int green, int blue)
{
this._red = red;
this._green = green;
this._blue = blue;
}
public int RED
{
get
{
return this._red;
}
set
{
this._red = value;
}
}
public int GREEN
{
get
{
return this._green;
}
set
{
this._green = value;
}
}
public int BLUE
{
get
{
return this._blue;
}
set
{
this._blue = value;
}
}
}
/// <summary>
/// 实现浅拷贝
/// </summary>
public class ConcretePrototype :ColorPrototype
{
/// <summary>
/// 长、宽、高
/// </summary>
private int _lenth, _hign, _wide;
private RGBColor _color = null;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="length"></param>
/// <param name="hign"></param>
/// <param name="wide"></param>
public ConcretePrototype(int length, int hign, int wide,RGBColor color)
{
this._wide = wide;
this._lenth = length;
this._hign = hign;
this._color = color;
}
public void SetRectangle(int length, int hign, int wide)
{
this._lenth = length;
this._wide = wide;
this._hign = hign;
}
public RGBColor SGRGBColor
{
set
{
this._color = value;
}
get
{
return this._color;
}
}
/// <summary>
/// 浅拷贝，只复制对象的基本类型.对象类型,仍属于原来的引用.
/// </summary>
/// <returns></returns>
public override ColorPrototype Clone()
{
//创建当前ConcretePrototype的浅拷贝
return (ColorPrototype)this.MemberwiseClone();
}
/// <summary>
/// 将对象的信息显示出来
/// </summary>
public void Display()
{
//注意this._lenth, this._hign, this._wide是值类型
Console.WriteLine("This rectangle's area: ({0},{1},{2})", this._lenth, this._hign, this._wide);
//注意this._color是引用类型
Console.WriteLine("This rectangle's color: ({0},{1},{2})", this._color.RED,this._color.GREEN,this._color.BLUE);
}
}
/// <summary>
/// 深拷贝
/// </summary>
[Serializable]
public class ConcretePrototypeDeep : ColorPrototype
{
/// <summary>
/// 长、宽、高
/// </summary>
private int _lenth, _hign, _wide;
private RGBColor _color = null;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="length"></param>
/// <param name="hign"></param>
/// <param name="wide"></param>
public ConcretePrototypeDeep(int length, int hign, int wide, RGBColor color)
{
this._wide = wide;
this._lenth = length;
this._hign = hign;
this._color = color;
}
public void SetRectangle(int length, int hign, int wide)
{
this._lenth = length;
this._wide = wide;
this._hign = hign;
}
public RGBColor SGRGBColor
{
set
{
this._color = value;
}
get
{
return this._color;
}
}
/// <summary>
/// 深度拷贝，不仅复制对象的基本类,同时也复制原对象中的对象.完全产生新对象。
/// </summary>
/// <returns></returns>
public override ColorPrototype Clone()
{
MemoryStream stream = new MemoryStream();
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, this);
stream.Position = 0;
return (ColorPrototype)formatter.Deserialize(stream);
}
public void Display()
{
Console.WriteLine("This rectangle's area: ({0},{1},{2})", this._lenth, this._hign, this._wide);
Console.WriteLine("This rectangle's color: ({0},{1},{2})", this._color.RED,this._color.GREEN,this._color.BLUE);
}
}
public class UsePrototype
{
public static void Main(string[] args)
{
Console.WriteLine("====== ====== 浅拷贝 ====== ======");
ColorPrototype colorPrototype = new ConcretePrototype(100, 200, 300,new RGBColor(20,100,130));
Console.WriteLine("原对象信息为：");
((ConcretePrototype)colorPrototype).Display();
ColorPrototype colorPrototypeClone = colorPrototype.Clone();
((ConcretePrototype)colorPrototypeClone).SetRectangle(150, 250, 350);
((ConcretePrototype)colorPrototypeClone).SGRGBColor.RED = 30;
((ConcretePrototype)colorPrototypeClone).SGRGBColor.GREEN = 120;
((ConcretePrototype)colorPrototypeClone).SGRGBColor.BLUE = 100;
Console.WriteLine("拷贝对象信息改变后为：");
((ConcretePrototype)colorPrototypeClone).Display();
Console.WriteLine("只复制对象的基本类型.对象类型,仍属于原来的引用");
((ConcretePrototype)colorPrototype).Display();
Console.WriteLine("====== ====== 深拷贝 ====== ======");
colorPrototype = new ConcretePrototypeDeep(100, 200, 300, new RGBColor(20, 100, 130));
Console.WriteLine("原对象信息为：");
((ConcretePrototypeDeep)colorPrototype).Display();
colorPrototypeClone = colorPrototype.Clone();
((ConcretePrototypeDeep)colorPrototypeClone).SetRectangle(150, 250, 350);
((ConcretePrototypeDeep)colorPrototypeClone).SGRGBColor.RED = 30;
((ConcretePrototypeDeep)colorPrototypeClone).SGRGBColor.GREEN = 120;
((ConcretePrototypeDeep)colorPrototypeClone).SGRGBColor.BLUE = 100;
Console.WriteLine("拷贝对象信息改变后为：");
((ConcretePrototypeDeep)colorPrototypeClone).Display();
Console.WriteLine("不仅复制对象的基本类,同时也复制原对象中的对象.完全产生新对象。");
((ConcretePrototypeDeep)colorPrototype).Display();
}
}
}
5、运行结果
可以看出，浅拷贝中，拷贝对象中的引用对象（RGBColor类对象）与原对象中的对应的引用对象（RGBColor类对象）指向同一个内存地址，而值信息则拷贝对象有一个另外的拷贝。
深拷贝中值变量和引用变量都重新开辟了一个内存，所以拷贝对象与原对象中的变量间所在的内存不一样。