设计模式之Prototype的学习笔记

设计模式之Prototype的学习笔记
Prototype (原型模式)
抽象不应该依赖于实现细节，实现细节应该依赖于抽象。
------抽象A依赖于抽象B，实现细节b依赖于抽象B。
动机（Motivation）
在软件系统中，经常面临着“某些结构复杂的对象”的创建工作；由于需求的变化
这些对象经常变量着剧烈的变化，但是它们却拥有比较稳定一致的接口。
如何应对这种变化？如何向“客户程序（使用这些对象的程序）”隔离出
“这些易变对象”，从而使得“依赖这些易变对象的客户程序”不随着改变而
改变？

意图（Intent）
使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。
先看一个例子：
public class GameSystem
{
public static void Run()
{
//需要5个小兵
NormalActor noramlActor1=new NormalActor();
NormalActor noramlActor2=new NormalActor();
NormalActor noramlActor3=new NormalActor();
NormalActor noramlActor4=new NormalActor();
NormalActor noramlActor5=new NormalActor();
//需要两个飞人
FlyActor flyActor1=new FlyActor();
FlyActor flyActor2=new FlyActor();
//需要潜水员
WaterActor waterActor1=new WaterActor ();
WaterActor waterActor2=new WaterActor ();
}
}

上边的代码依赖关系很强，如果这个场景中就需要这么些类型的人
整个场景都保持不变，ok上面的代码可以，没问题。
但是需求往往需要变化的，比如我要6个小兵，或者再需要一类人。
上边这种强依赖关系就不能满足要求了
那又该如何来更改这个代码？
再看一个例子：

//抽象接口
public abstract class NormalActor
{
public abstract NormalActor Clone();
}

public abstract class FlyActor
{
public abstract FlyActor Clone();
}

public abstract class WaterActor
{
public abstract WaterActor Clone();
}
//具体实现
public class NormalActorA:NormalActor
{
public override NormalActor Clone()
{
return (NormalActor)this.MemberwiseClone();
}
}

public class FlyActorA:FlyActor
{
public override FlyActor Clone()
{
return (FlyActor)this.MemberwiseClone();
}
}

public abstract class WaterActorA:WaterActor
{
public override WaterActor.Clone()
{
return (WaterActor)this.MemberwiseClone();
}
}

public class GameSystem
{
public static void Run(NormalActor normalActor,
FlyActor flyactor,
WaterActor waterActor
)//如果把参数定义成属性也可以的不影响设计模式的实现。
{
//需要5个小兵
NormalActor noramlActor1=normalActor.Clone();//克隆
NormalActor noramlActor2=normalActor.Clone();
NormalActor noramlActor3=normalActor.Clone();
NormalActor noramlActor4=normalActor.Clone();
NormalActor noramlActor5=normalActor.Clone();
//需要两个飞人
FlyActor flyActor1=flyactor.Clone();
FlyActor flyActor2=flyactor.Clone();
//需要潜水员
WaterActor waterActor1=waterActor.Clone();
WaterActor waterActor2=waterActor.Clone();
}
}

//客户程序
class App
{
public static void Main()
{
GameSystem gamesystem=new GameSystem();
gamesystem.Run(new NormalActorA(),
new FlyActorA(),
new WaterActorA())

}
}

注意上边的代码中 MemberwiseClone 它是一个类的前拷贝。如类中的属性是
值类型比如说int a ,bety b, string s;这些属性定义的变量MemberwiseClone
克隆没有问题，如果类里面有一个数组 int [] a;MemberwiseClone 克隆的就是它
的地址了。这样克隆就会存在问题。

如何解决这个问题？
最差劲的做法就是先new 一个东西 然后一步步再把它们给复制过来。
还有一种做法其实是蛮取巧的就是我们讲的那个用序列化的方式，其实序列化
就要求我们这样在这个类上声明这样一个标记，声明这样一个标记之后，可以
先将这样一个类序列化到这个内存流上然后再进行一个反序列化，那反序列化
得到的对象或原来的对象一定就是一个深拷贝关系

Prototype 模式的几个要点
Prototype 模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合
关系，它同样要求这些易变类拥有稳定的接口。
prototype 模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法
来做，他使得我们可以非常灵活地动态创建“拥有某些稳定接口”的新对象
---------所需工作仅仅是注册一个新类的对象（即原型），然后在任何
需要的地方不断地Clone。
prototype模式中的Clone 方法可以利用.net中的Object类的MemberwiseClone()
方法或者序列化来实现深拷贝。

有关创建型模式的讨论
Singletion 模式解决的是实体对象个数的问题。出了Singletion
之外，其他创建型模式解决的都是new 的耦合关系。

Factory Method，Abstract Factory，Builder都需要一个额外的工厂类来
负责实例化“易变对象”，而Prototype则是通过一个原型（一个特殊的工厂类）
来克隆易变对象。
如果遇到“易变类”起初的设计通常从Factory Method开始，当遇到更多的复杂变化
时，再考虑重构为其他三种工厂模式（Abstract Factory，Builder，
Prototype）。