GOF之原型模式

依赖关系的倒置

抽象不应该依赖与实现细节，实现细节应该依赖与抽象。

-抽象A直接依赖与实现细节b　　　　　　　　　　　　　　　　　　　　-抽象A依赖与抽象B，实现细节b依赖与抽象B

动机(Motivation)

在软件系统中，经常面临着“某些结构复杂的对象”的创建工作;由于需求的变化，这些对象经常面临着剧烈的变化，但是它们却拥有比较稳定一致的接口。

如何应对这种变化？如何向“客户程序(使用这些对象的程序)”隔离出“这些易变对象”，从而使得“依赖这些易变对象的客户程序”不随着需求改变而改变？

意图(Intent)

使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。

结构(Structure)

代码实现：

对应于Prototype
public abstract class Actor
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public abstract Actor Clone(string name);
        public abstract void Say();
    }

对应于ConcretePrototype
class ActorA:Actor
    {
        
        public override Actor Clone(string name)
        {
            Actor actor = (Actor)this.MemberwiseClone();
            actor.Name ="ActorA"+name;
            return actor;
        }
        public override void Say()
        {
            Console.WriteLine("ActorA is say hai");
        }
    }

    class ActorB : Actor
    {

        public override Actor Clone(string name)
        {
            Actor actor = (Actor)this.MemberwiseClone();
            actor.Name = "ActorB" + name;
            return actor;
        }
        public override void Say()
        {
            Console.WriteLine("ActorB is say hai");
        }
    }

对应于Client
class Manager
    {
        private Actor _actor;

        public Actor Actor
        {
            get { return _actor; }
            set { _actor = value; }
        }
        public Manager(Actor actor)
        {
            this.Actor = actor;
        }
        public void Operation()
        {
            Actor a1 = Actor.Clone("zs");
            Actor a2 = Actor.Clone("ls");
            a1.Say();
            a2.Say();
            Console.WriteLine(a1.Name+"     "+a2.Name);
            Console.WriteLine(object.ReferenceEquals(a1,a2));
        }
    }

主函数的调用
 static void Main(string[] args)
        {
            Manager manager = new Manager(new ActorB());
            manager.Operation();
            Console.ReadKey();
        }

由于调用Object的MemberwiseClone()实现的是浅拷贝，所以用序列化实现深拷贝

通过序列化实现深拷贝
 //深拷贝
        public override Actor CloneDeep(string name)
        {
            Actor actor;
            //创建内存流
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                //序列化成流
                bf.Serialize(ms,new ActorA());
                ms.Seek(0, SeekOrigin.Begin);
                //反序列化成对象
                actor = (Actor)bf.Deserialize(ms);
            }
            actor.Name = name;
            return actor;
        }

Prototype模式的几个要点：

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

Prototype模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来做，它使得我们可以非常灵活的动态创建“拥有某些稳定接口”的新对象--所需工作仅仅是注册一个新类的对象(即原型)，然后在任何需要的地方不断的Clone。

Prototype模式中的Clone方法可以利用.NET中的Object类的MemberwiseClone()方法或者序列化来实现深拷贝。

有关创建型模式的讨论：

Singleton模式解决的是实体对象个数的问题。除了Singleton之外，其他创建型模式解决的都是new所带来的耦合关系。

Factory Method, Abstract Factory, Builder都需要一个额外的工厂类来负责实例化“易变对象”，而Prototype则是通过原型(一个特殊的工厂类)来克隆“易变对象”。

如果遇到“易变类”，起初的设计通常从Factory Method开始，当遇到更多的复杂变化时，在考虑重构为其他三种工厂模式(Abstract Factory,Builder,Singleton)。