一：创建型五个模式概念
单例模式、工厂方法、抽象工厂、建造者模式、原形模式
创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。
二：五个模式以及代码实现
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();
}
}
