创建型：Creational

1、简单工厂模式：SimpleFactory

void Main()
{
SimpleFactory.GetProduct("A").Dump();
SimpleFactory.GetProduct("B").Dump();
}


// Define other methods and classes here
class Product{}  //父类
class ProductA:Product{}  //子类继承父类
class ProductB:Product{}   //子类继承父类
class SimpleFactory{
public static Product GetProduct(string productName){
switch (productName)
{
case "A": return new ProductA();
case "B": return new ProductB();
default: throw new NullReferenceException();
}
}
}

2、工厂方法模式：FactoryMethod

void Main()
{
Factory.ChooseFactory("A").GetProduct().Dump();
Factory.ChooseFactory("B").GetProduct().Dump();
}


// Define other methods and classes here
class Product{}
class ProductA:Product{}
class ProductB:Product{}


abstract class Factory{
public static Factory ChooseFactory(string factoryName){
switch (factoryName)
{
case "A": return new FactoryA();
case "B": return new FactoryB();
default: throw new NullReferenceException();
}
}
public abstract Product GetProduct();
}
class FactoryA:Factory{
public override Product GetProduct(){
return new ProductA();
}
}
class FactoryB:Factory{
public override Product GetProduct(){
return new ProductB();
}
}

3、抽象工厂模式：AbstractFactory

void Main()
{
AbstractFactory.ChooseFactory("A").GetProduct1().Dump();
AbstractFactory.ChooseFactory("A").GetProduct2().Dump();
AbstractFactory.ChooseFactory("B").GetProduct1().Dump();
AbstractFactory.ChooseFactory("B").GetProduct2().Dump();
}


class Product1{}
class Product2{}
class Product1A:Product1{}
class Product1B:Product1{}
class Product2A:Product2{}
class Product2B:Product2{}


abstract class AbstractFactory{
public static AbstractFactory ChooseFactory(string factoryName){
switch (factoryName)
{
case "A": return new FactoryA();
case "B": return new FactoryB();
default: throw new NullReferenceException();
}
}
public abstract Product1 GetProduct1();
public abstract Product2 GetProduct2();
}
class FactoryA:AbstractFactory{
public override Product1 GetProduct1(){
return new Product1A();
}
public override Product2 GetProduct2(){
return new Product2A();
}
}
class FactoryB:AbstractFactory{
public override Product1 GetProduct1(){
return new Product1B();
}
public override Product2 GetProduct2(){
return new Product2B();
}
}

4、单例模式：Singleton

void Main()
{


private static Singleton instance = null;
private static object obj = new object();
public static Singleton GetInstance(){
if (instance==null)
{
lock (obj)
{
if (instance==null)
{
instance = new Singleton();
}
}
}
return instance;
}
}

5、原型模式：Prototype

void Main()
{
Prototype p1 = new Prototype();
p1.Dump();

Prototype p2 = p1.Clone() as Prototype;
p2.Dump();

object.ReferenceEquals(p1,p2).Dump();
}


// Define other methods and classes here
class Prototype:ICloneable{
public object Clone(){
return this.MemberwiseClone();
}
}

6、建造者模式：Builder

void Main()
{
Director d = new Director();

d.Set(new BuilderA());
d.Show();

d.Set(new BuilderB());
d.Show();
}

class Director{
private Builder builder;
public void Set(Builder b){ this.builder = b; }
public void Show(){
builder.ShowA();
builder.ShowB();
builder.ShowC();
}
}
abstract class Builder{
public abstract void ShowA();
public abstract void ShowB();
public abstract void ShowC();
}
class BuilderA:Builder{
public override void ShowA(){ "BuilderA-ShowA".Dump(); }
public override void ShowB(){ "BuilderA-ShowB".Dump(); }
public override void ShowC(){ "BuilderA-ShowC".Dump(); }
}
class BuilderB:Builder{
public override void ShowA(){ "BuilderB-ShowA".Dump(); }
public override void ShowB(){ "BuilderB-ShowB".Dump(); }
public override void ShowC(){ "BuilderB-ShowC".Dump(); }
}