原型模式

原型模式：用原型实例指定创建对象的种类，并且通过这些原型创建新的对象。也就是活从一个对象再创建另外一个可定制的对象，并且不许知道任何创建的细节。

 abstract class Prototype
    {
        private string id;

        public Prototype(string id)
        {
            this.id = id;
        }

        public string Id
        {
            get { return id; }
        }
        public abstract Prototype Clone();
    }

    class ConcretePrototype : Prototype
    {
        public ConcretePrototype(string id)
            : base(id)
        {
        }
        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ConcretePrototype p1 = new ConcretePrototype("I");
            Console.WriteLine(p1.Id);
            ConcretePrototype c1 = (ConcretePrototype)p1.Clone();
            Console.WriteLine(c1.Id);
            Console.Read();
        }
    }`

.Net在System命名空间中提供了IConeable接口，其中就是唯一的一个方法Clone(),这样只需要实现这个接口就可以完成原型模式，下面是一个人的信息类：

class Person : ICloneable
    {
        private string name;
        private string sex;
        private int  age;

        public Person(string name)
        {
            this.name = name;
        }

        public void SetPersonInfo(string sex, int age)
        {
            this.sex = sex;
            this.age = age;
        }

        public void OutPut()
        {
            Console.WriteLine(name);
            Console.WriteLine("性别:" + sex);
            Console.WriteLine("年龄:" + age);
        }

        public Object Clone()
        {
            return (Object)this.MemberwiseClone();
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person("xiaoming");
            p.SetPersonInfo("nan", 18);

            Person cp = (Person)p.Clone();
            p.OutPut();
            Console.Read();
        }
    }

一般在初始化信息不发生改变的情况下，克隆是最好的办法，这既隐藏了对象创建的细节，又对性能是大大的提高。类似于不用重新初始化对象，而是动态的获得对象运行时的状态。

MemberwiseClone()方法：如果字段是值类型，则对该字段执行逐位复制，如果字段是引用类型，则复制引用但不复制引用对象。

class School
    {
        private string name;
        private string grade;
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        public string Grade
        {
            get
            {
                return grade;
            }
            set
            {
                grade = value;
            }
        }

    }
    class Person : ICloneable
    {
        private string name;
        private string sex;
        private int  age;
        private School s = new School();
        public Person(string name)
        {
            this.name = name;
        }

        public void SetPersonInfo(string sex, int age)
        {
            this.sex = sex;
            this.age = age;
        }
        public void SetSchool(string n, string g)
        {
            s.Grade = g;
            s.Name = n;
        }
        public void OutPut()
        {
            Console.WriteLine(name);
            Console.WriteLine("性别:" + sex);
            Console.WriteLine("年龄:" + age);
            Console.WriteLine("学校:" + s.Name+"年级:"+s.Grade);

        }

        public Object Clone()
        {
            return (Object)this.MemberwiseClone();
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person("xiaoming");
            p.SetPersonInfo("nan", 18);
            p.SetSchool("szu", "大三");
            p.OutPut();
            Person cp = (Person)p.Clone();
            cp.SetSchool("sh", "大四");
            p.OutPut();
            cp.OutPut();
            Console.Read();
        }
    }

上述复制的过程为浅复制，被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。但要把复制的对象所引用的对象都复制一遍，就是深复制。

 class School :ICloneable
    {
        private string name;
        private string grade;
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        public string Grade
        {
            get
            {
                return grade;
            }
            set
            {
                grade = value;
            }
        }
        public Object Clone()
        {
            return (Object)this.MemberwiseClone();
        }

    }
    class Person : ICloneable
    {
        private string name;
        private string sex;
        private int  age;
        private School s;
        public Person(string name)
        {
            s = new School();
            this.name = name;
        }
        private Person(School s)
        {
            this.s = (School)s.Clone();
        }
        public void SetPersonInfo(string sex, int age)
        {
            this.sex = sex;
            this.age = age;
        }
        public void SetSchool(string n, string g)
        {
            s.Grade = g;
            s.Name = n;
        }
        public void OutPut()
        {
            Console.WriteLine(name);
            Console.WriteLine("性别:" + sex);
            Console.WriteLine("年龄:" + age);
            Console.WriteLine("学校:" + s.Name+"年级:"+s.Grade);

        }

        public Object Clone()
        {
            Person per = new Person(this.s);
            per.name = this.name;
            per.sex = this.sex;
            per.age = this.age;
            return per;
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person("xiaoming");
            p.SetPersonInfo("nan", 18);
            p.SetSchool("szu", "大三");
            p.OutPut();
            Person cp = (Person)p.Clone();
            cp.SetSchool("sh", "大四");
            p.OutPut();
            cp.OutPut();
            Console.Read();
        }
    }

创建型模式总结：
工厂模式：根据提供给工厂的数据，从一系列相关的类中选择一个实例并返回。
抽象工厂模式：用于返回一组类中的一个，在某些情况下，实际上为一组类返回了一个工厂。
生成器模式：根据提供给它得数据以及表示，将一系列对象组装成一个新对象，通常选择何种方式组装对象由工厂决定。
当创建新实例代价比较高的时候，原型模式拷贝（深复制）或克隆（浅复制）一个现有的类，而不是创建一个新实例。
单例模式可以保证有且只有一个对象实例，并提供一个该实例的全局访问点。