设计模式速查版 - 创建型
1.工厂方法
1)结构图:
2)代码:
/// 抽象工厂
public interface IFactory
{
/// <summary></summary>
Product FactoryMethod();
}
/// 抽象产品类
public abstract class Product
{
public virtual void show()
{
Console.Write("I'm product");
}
}
/// 工厂A
public class FactoryA : IFactory
{
/// <summary></summary>
public Product FactoryMethod()
{
return new ProductA();
}
}
/// 工厂B
public class FactoryB : IFactory
{
/// <summary></summary>
public Product FactoryMethod()
{
return new ProductB();
}
}
/// 产品A
public class ProductA : Product
{
public override void show()
{
Console.Write("I'm productA");
}
}
/// 产品B
public class ProductB : Product
{
public override void show()
{
Console.Write("I'm productB");
}
}
class Program
{
static void Main(string[] args)
{
IFactory factory = new FactoryA(); //控制具体要哪个产品
Product product = factory.FactoryMethod();
product.show();
Console.ReadLine();
}
}
3)
优点: 工厂方法使得一个类的实例化延迟到其子类.
适用: 客户端的加工逻辑只需要知道是哪类产品,而不需知道具体的产品名.这样不同的产品就可以复用相同的加工逻辑.
2.抽象工厂
1)结构图:
2)代码:
/// <summary>
/// 抽象工厂
/// </summary>
public interface IAbstractFactory
{
/// <summary></summary>
AbstractProductA CreateProductA();
/// <summary></summary>
AbstractProductB CreateProductB();
}
/// 工厂1
public class Factory1 : IAbstractFactory
{
/// 生产系列1的A产品
public AbstractProductA CreateProductA()
{
return new ProductA1();
}
/// 生产系列1的B产品
public AbstractProductB CreateProductB()
{
return new ProductB1();
}
}
/// 工厂2
public class Factory2 : IAbstractFactory
{
/// 生产系列2的A产品
public AbstractProductA CreateProductA()
{
return new ProductA2();
}
/// 生产系列2的B产品
public AbstractProductB CreateProductB()
{
return new ProductB2();
}
}
/// 抽象A产品
public abstract class AbstractProductA
{
}
/// 系列1的A产品
public class ProductA1 : AbstractProductA
{
}
/// 系列2的A产品
public class ProductA2 : AbstractProductA
{
}
/// 抽象B产品
public abstract class AbstractProductB
{
}
/// 系列1的B产品
public class ProductB1 : AbstractProductB
{
}
/// 系列2的B产品
public class ProductB2 : AbstractProductB
{
}
class Program
{
static void Main(string[] args)
{
IAbstractFactory factory = new Factory1(); //控制生成哪个系列的产品
AbstractProductA productA = factory.CreateProductA();
AbstractProductB productB = factory.CreateProductB();
//TODO..
Console.ReadLine();
}
}
3)
优点: 与工厂方法类似
适用: 适合那些客户端的操作逻辑与具体哪一系列产品无关的操作,她隔离了系列产品的创建和产品操作逻辑.所以可以使得不同系列的产品复用相同的操作逻辑.
tips: 可以用反射注入,这样在换系列产品的时候无需修改客户端代码.
3.建造者模式
1)简介: 通过一个构造器接口,让子类去实现具体的构造方法和逻辑,利用构造器接口去向客户端屏蔽目标对象具体的构造过程.同时,可以通过添加新的构造者去添加产生不同构造的目标对象(由于面向接口编程,所以客户端不知道这一变化).
2)结构图:
3)代码:
/// 构造者接口
public interface IBuilder
{
/// <summary></summary>
void BuildPart1();
/// <summary></summary>
void BuildPart2();
/// <summary></summary>
void BuildPart3();
/// <summary></summary>
Product GetProduct();
}
/// 具体构造者A,即含不同的构造逻辑
public class BuilderA : IBuilder
{
//组合Product,实现对Product的不同部分的构造
private Product _product;
public BuilderA()
{
_product = new Product();
}
/// 对Part1进行逻辑操作
public void BuildPart1()
{
//TODO
_product.Part1 = new object();
}
/// <summary></summary>
public void BuildPart2()
{
//TODO
}
/// <summary></summary>
public void BuildPart3()
{
//TODO
}
/// <summary></summary>
public Product GetProduct()
{
return _product;
}
}
/// 具体构造者B,即含不同的构造逻辑
public class BuilderB : IBuilder
{
//组合Product,实现对Product的不同部分的构造
private Product _product;
public BuilderB()
{
_product = new Product();
}
/// 对Part1进行逻辑操作
public void BuildPart1()
{
//TODO
_product.Part1 = new object();
}
/// <summary></summary>
public void BuildPart2()
{
//TODO
}
/// <summary></summary>
public void BuildPart3()
{
//TODO
}
/// <summary></summary>
public Product GetProduct()
{
return _product;
}
}
/// 目标产品
public class Product
{
public object Part1 { get; set; }
public object Part2 { get; set; }
public object Part3 { get; set; }
}
/// 控制着构造者构造Product的过程,同时起到对客户端隔离了Product的构造过程.
public class Manager
{
/// 根据不同的Builder来构造
public void Construct(IBuilder builder)
{
builder.BuildPart1();
builder.BuildPart2();
builder.BuildPart3();
//这里还可以控制构造Product的部分,比如构造其中的某几个部分
}
}
class Program
{
static void Main(string[] args)
{
Manager manager = new Manager();
IBuilder bA = new BuilderA();
IBuilder bB = new BuilderB();
//根据要求不同要求去构造Product
manager.Construct(bA);
Product pA = bA.GetProduct();
manager.Construct(bB);
Product pB = bB.GetProduct();
//TODO..
Console.ReadLine();
}
}
4)
适用: 适用于目标对象构造比较复杂,或者构造过程可能变化的时候.
4.原型模式
1)简介:
用一个原型类的实例去创建一个新的对象,这个新的对象是由原实例对象拷贝过来的(相当于将原对象复制一份生成)
2)结构图:
3)代码:
/// 原型
public abstract class Prototype
{
//tips:抽象类也是有构造函数的,因为他要被人继承,其子类实例化过程也是和普通类一样,先从最根处向下实例化
public Prototype(string member)
{
this.member1 = member;
}
protected string member1;
/// <summary></summary>
public abstract Prototype Clone();
}
/// 原型A
public class PrototypeA : Prototype
{
protected string member2;
public string Member2 { get { return member2;} }
public PrototypeA(string member1,string member2)
: base(member1)
{
this.member2 = member2;
}
/// 克隆实例对象自身(包括父类)
public override Prototype Clone()
{
//C#的话可以采用这种浅复制
return (Prototype)this.MemberwiseClone();
//若是其他语言没有类似语言则先new个对象,再将值赋进去,然后return这个对象
}
}
/// 原型B
public class PrototypeB : Prototype
{
/// <summary></summary>
public override Prototype Clone()
{
}
}
/// 原型AA
public class PrototypeAA : PrototypeA
{
protected string member3;
public string Member3 { get { return member3; } }
public PrototypeAA(string member1, string member2, string member3)
: base(member1, member2)
{
this.member3 = member3;
}
/// /// 克隆实例对象自身(包括父类)
public override Prototype Clone()
{
//C#的话可以采用这种浅复制
return (Prototype)this.MemberwiseClone();
//若是其他语言没有类似语言则先new个对象,再将值赋进去,然后return这个对象
}
}
class Program
{
static void Main(string[] args)
{
PrototypeA PA = new PrototypeA("m1", "m2");
PrototypeA PA2 = (PrototypeA)PA.Clone();
Console.Write(PA2.Member2);
PrototypeAA PAA = new PrototypeAA("m1", "m2", "m3");
PrototypeAA PAA2 = (PrototypeAA)PAA.Clone();
Console.Write(PAA2.Member3);
//TODO
Console.ReadLine();
}
}
4)适用:
适用于需要生成的对象具有父类实例对象的特性(着重点在于是实例对象,即运行时对象),即想让生成对象要具有和某一对象相同的属性,则可考虑采用原型模式(通常需要目标类是原类的子类或后代且都拥有Clone方法,后代重写Clone方法去复制自身对象实例)
5.单例模式
1）简介:
保证一个类仅有一个实例,并提供一个访问它的全局访问点.为了保证实例对象的唯一性,让类自身负责保存它的唯一实例.通常做法是1.私有化类构造方法(隔离外部访问) 2.提供一个公共的静态化生成实例方法(保证有唯一访问点)
2)结构图:
3)代码:
/// 单例
class Singleton
{
private static Singleton _instance;
private Singleton() { }
public static Singleton GetInstance(){
return _instance == null ? _instance=new Singleton() : _instance;
}
}
class Program
{
static void Main(string[] args)
{
Singleton s1 = Singleton.GetInstance();
Singleton s2 = Singleton.GetInstance();
//生成实例是同一个
Console.Write(s1 == s2);
//TODO
Console.ReadLine();
}
}
4)适用:
要求某个类在全局条件下只生成一个实例对象.