原型模式的定义

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。prototype模式允许一个对象再创建另外一个可定制对的对象，根本无需知道任何创建的细节，工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝他们自己来实施创建。

动机（Motivation）

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

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

场景

我们在做一个游戏程序（GameSystem），现在我们需要五个普通的小兵，两个会飞的小兵和两个能在水里游的小兵，我们刚开始可能会这样实现

namespace Prototype
{
    public class GameSystem
    {
        public void Run()
        {
            NormalActor normalActor1 = new NormalActor();
            NormalActor normalActor2 = new NormalActor();
            NormalActor normalActor3 = new NormalActor();

            NormalActor normalActor4 = new NormalActor();

            NormalActor normalActor5 = new NormalActor();

            FlyActor flyActor1 = new FlyActor();

            FlyActor flyActor2 = new FlyActor();

            WaterActor waterActor1 = new WaterActor();

            WaterActor waterActor2 = new WaterActor();
        }
    }

    public class NormalActor
    {
    }

    public class FlyActor
    {
    }

    public class WaterActor
    {
    }
}

但是这种实现违背了我们刚开始讲的依赖关系倒置的思想，GameSystem这个抽象依赖了实现细节，具体的NormalActor和

FlyActor以及WaterActor，这个时候如果这些具体点额实现细节改变的话，对我们的开发会造成很大的麻烦。这个时候怎么办呢？我们完全可以用设计模式来实现这个功能而避免因改变而造成的困境，比如工厂方法，抽象工厂，我们也可以用原型模式来实现。我们来看原型模式的实现代码

namespace Prototype
{
    public class GameSystem
    {
        public void Run(NormalActor normalActor, FlyActor flyActor, WaterActor waterActor)
        {
            NormalActor normalActor1 = normalActor.Clone();
            NormalActor normalActor2 = normalActor.Clone();
            NormalActor normalActor3 = normalActor.Clone();

            NormalActor normalActor4 = normalActor.Clone();

            NormalActor normalActor5 = normalActor.Clone();

            FlyActor flyActor1 = flyActor.Clone();

            FlyActor flyActor2 = flyActor.Clone();

            WaterActor waterActor1 = waterActor.Clone();

            WaterActor waterActor2 = waterActor.Clone();
        }
    }
    #region 抽象类

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

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

    public abstract class WaterActor
    {
        public abstract WaterActor Clone();
    } 
    #endregion

    #region 具体的实现类
    public class NormalActorA : NormalActor
    {
        public override NormalActor Clone()
        {
            return (NormalActor)this.MemberwiseClone();
        }
    }

    public class NormalActorB : NormalActor
    {
        public override NormalActor Clone()
        {
            return (NormalActor)this.MemberwiseClone();
        }
    }

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

    public class FlyActorB : FlyActor
    {
        public override FlyActor Clone()
        {
            return (FlyActor)this.MemberwiseClone();
        }
    }
    //WaterActorA
    public class WaterActorA : WaterActor
    {
        public override WaterActor Clone()
        {
            return (WaterActor)this.MemberwiseClone();
        }
    }
    //WaterActorB
    public class WaterActorB : WaterActor
    {
        public override WaterActor Clone()
        {
            return (WaterActor)this.MemberwiseClone();
        }
    } 
    #endregion
}

利用了.NET框架的Clone，但是这个MemberwiseClone是一个浅拷贝，所以如果类里面有引用类型的实例话会拷贝出同一个对象。我们可以用序列化和反序列化的方式得到一个我们想要得到的对象。这就是原型模式的实现方式，