一：创建型五个模式概念

单例模式、工厂方法、抽象工厂、建造者模式、原形模式
创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。

二：五个模式以及代码实现

2.1 单例模式

基本概念：
单例模式的方法创建的类在当前进程中只有一个实例

	internal class Single
    {
      	 private  static Single single;   //建立一个全局对象
        private Single()    //将构造函数进行隐藏，外部不可访问
        { }
        public  static Single GetSingle()
        {
            if (single ==null)  //如果第一次访问的话，就完成对象初始化
            {
                single = new Single();
            }
            return single;
        }
    }

单例模式一共有三个要点。
1.某个类只能有一个实例；
2.它必须自行创建这个实例。
3.它必须向整个系统提供这个实例。
对应到代码上来说就是：私有构造函数、私有静态对象、共有创建获取的方法。

2.2工厂方法模式

工厂三姐妹分别是简单工厂、工厂方法、抽象工厂,此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类。工厂方法有四个核心，分别为抽象工厂；具体工厂；抽象产品；具体产品。

 //抽象的工厂
    internal interface ICreator 
    {
        //返回一个产品
        IProduct FactoryMethod();
    }
    //抽象的产品
    interface IProduct
    {    
    }
    //具体的工厂
    class ConcreteCreator : ICreator
    {
        //创建的是一个具体的产品
        public IProduct FactoryMethod()
        {
            return new ConcreteProduct();
        }
    }
    //具体的产品
    class ConcreteProduct : IProduct
    { }

最后创建的是具体的产品。如果增加了新的需求的话，我们可以增加一个新的工厂，然后增加一个新的产品。客户端依赖的是抽象的产品和抽象的工厂

2.3 抽象工厂模式

抽象工厂模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

也就是说和工厂方法相比，抽象工厂抽象的是各类工厂，具体工厂可以实现为多个工厂。抽象产品也有多个，并且每个抽象产品下面都可以实现多个具体的产品。

2.4建造者模式

指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
建造者由产品、抽象建造者、具体建造者、指挥者、四个部分组成。

    //产品
    class Product
    {
        //产品属性
        private string A;
        private string B;
        private string C;

        //给产品属性赋值的方法
        public void setPartA(string A)
        {
            this.A = A;
        }
        public void setPartB(string B)
        {
            this.B = B;
        }
        public void setPartC(string C)
        {
            this.C = C;
        }
    }
    //抽象的建造者
    abstract class Builder
    {
        //创建产品对象
        protected Product product = new Product();
        //产品对象的具体构造，父类定义了构造结构，子类具体构造
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract void BuildPartC();
        //获得产品对象
        public Product GetProduct() { 
            return product;
        }
    }
    //具体建造者
    class ConcreteBuilder1 : Builder
    {
        public override void BuildPartA()
        {
            product.setPartA("属性1A");
        }

        public override void BuildPartB()
        {
            product.setPartB("属性1B");
        }

        public override void BuildPartC()
        {
            product.setPartC("属性1C");
        }
    }
    //具体建造者2
    class ConcreteBuilder2 : Builder
    {
        public override void BuildPartA()
        {
            product.setPartA("属性2A");
        }

        public override void BuildPartB()
        {
            product.setPartB("属性2B");
        }

        public override void BuildPartC()
        {
            product.setPartC("属性2C");
        }
    }

    //指挥者
    class Direcotr {
        //声明一个建造者对象
        private Builder builder;
        //指挥者的构造函数,因为指挥者类就是为了指挥建造者建造产品的，所以在构造函数里传入
        public Direcotr(Builder builder)    //这里传进来的是具体的建造者的对象
        {
            this.builder = builder;
        }
        //下面的方法为具体建造过程方法
        public Product Construct() {
            builder.BuildPartA();   //先建造1
            builder.BuildPartB();   //在建造2
            builder.BuildPartC();   //在建造3
            return builder.GetProduct();    //获得建造好得对象
        }
    }

2.5原型模式

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。
原型模式包含以下主要角色。

抽象原型类：规定了具体原型对象必须实现的接口。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

原型模式的克隆分为浅克隆和深克隆。

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

    //抽象类
    abstract class Prototype
    {
        private string id;
        public Prototype(string id)
        {
            this.id = id;
        }
        public string Id
        { get { return this.id; } }

        public abstract Prototype Clone();
    }

    class ConcretePrototype1 : Prototype
    {
        public ConcretePrototype1(string id) : base(id)
        { }
        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }


    }