设计模式C#实现（八）——原型模式

原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。（要创建一个对象，这个对象为实现原型接口，方法是原型克隆。克隆只是方法而不是原型模式的目的，创建对象才是目的）

UML类图：

构成：

1.原型接口，提供给客户操作，声明一个clone()方法，用于克隆自身创建另一个实例

2.原型，实现clone()方法，分为浅层克隆和深层克隆。浅层克隆，值类型成员的值相同，但是在内存是存储在不同空间上的，而引用类型成员是相同的引用，即是同一块内存空间，修改其中一个，另一个也随之改变。而深层克隆，不论是值类型还是引用类型，都是不同的内存。

以电脑为例，先定义电脑接口，包含clone()方法

 interface Computer
    {
        string CPU { get; set; }
        string Memory { get; set; }
        //string GPU { get; set; }
        GPU GPU { get; set; }
        Computer clone();
        Computer deepClone();
    }

原型实现这个接口，因为.NET所有类都是object的子类，而object类有一个MemberwiseClone()方法返回自身的浅层克隆，所以可以用它实现浅层克隆clone()（自己实现?）。而深层克隆deepClone()是用序列化和反序列化实现的（这个现在还不懂为什么）

class ComputerPrototype : Computer
    {
        private string cpu;
        private string memory;
        private GPU gpu;
        public Computer clone()
        {
            return (Computer)this.MemberwiseClone();
        }
        public Computer deepClone()
        {
            MemoryStream stream = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(stream, this);
            stream.Position = 0;
            return formatter.Deserialize(stream) as Computer;
        }
        public override string ToString()
        {
            return CPU + "\n" + Memory + "\n" + GPU.Producer+" "+gpu.Type;
        }
        public GPU GPU
        {
            get { return gpu; }
            set { gpu = value; }
        }
        public string Memory
        {
            get { return memory; }
            set { memory = value; }
        }
        public string CPU
        {
            get { return cpu; }
            set { cpu = value; }
        }
    }

Computer包含一个类GPU，用来演示浅层和深层克隆的不同，它被标记为可序列化

[Serializable]
    class GPU
    {
        public GPU(string producer, string type)
        {
            this.Producer = producer;
            this.Type = type;
        }
        public string Producer
        {
            get;
            set;
        }
        public string Type
        {
            get;
            set;
        }
    }

先实例化一个ComputerPrototype原型，再为它的成员赋值，接下来，通过浅层克隆方法clone()创建一个实例，修改新实例的成员，最后查看两个实例的异同

class Program
    {
        static void Main(string[] args)
        {
            Computer low = new ComputerPrototype();
            low.CPU = "e3 1231v3";
            low.Memory = "4 G";
            low.GPU = new GPU("凄惨红", "GTX970");
            //Computer high = low.deepClone();
            Computer high = low.clone();

            high.GPU.Producer = "高贵的阿苏斯";
            high.Memory = "8 G";
            Console.Write("GPU是否是同一引用:");
            Console.WriteLine(low.GPU == high.GPU);

            Console.WriteLine("Low:");
            Console.WriteLine(low.ToString());
            Console.WriteLine("High:");
            Console.WriteLine(high.ToString());
            Console.ReadKey();
        }
    }