C#中的设计原则和创建型设计模式
七大设计原则:
1.SRP:单一职责,即设计类时,类的功能越少越好.
2.OCP:开放封闭原则,即对外扩展开放,对内修改封闭.
3.DIP:依赖倒置原则,即高端类尽量依赖于接口,而不依赖于低端类.
4.LSP:里氏替换原则,即子类代替父类.
5.LOD:迪米特法则,即类和类之间的关联关系越少越好.
6.ISP:接口隔离原则,即一个类对另外一个类的依赖性应当是建立在最小的接口上的.
7.CARP:合成聚合复用原则,即能使用组合方式编码,不采用继承.
二十三种设计模式可分为创建型(5+1),结构型(7)和行为型(11).
1.简单工厂根据用户参数实例化具体子类,以父类类型返回.环境要求所有子类继承于同一个父类.
2.工厂模式:把子类产品的实例化延迟到更小一级的子类工厂.
3.抽象工厂模式:解决一系列相关或相依赖的子类产品实例化问题.
4.单例模式:一个类只能被实例化一次.
5.原型:根据对象值创建副本.
6.建造者模式:把固定的结构和具体的表现形式剥离开,分装结构.
单例模式可以确保每个类仅有一个实例,并且提供一个全局访问点.
单例模式其实也是一种职责型模式.因为我们创建了一个对象,这个对象扮演了独一无二的角色,在这个单
独的对象例中,它集中了它所属类的所有权力,同时它也肩负了行使这种权力的职责.
示例代码:
public partial class frmAbout : Form
{
private frmAbout()
{
InitializeComponent();
}
private static frmAbout instance = null;
public static object obj = new object();
public static frmAbout GetInstance()
{
if (instance == null || instance.IsDisposed)
{
lock (obj)
{
if (instance == null || instance.IsDisposed)
{
instance = new frmAbout();
}
}
}
return instance;
}
工厂和抽象工厂的区别:
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
具体一点：抽象工厂就像工厂，而工厂方法则像是工厂中一种产品生产线。
抽象工厂代码:
void Main()
{
AbstractFactory.ChooseFactory("1").GetProductA().Dump();
AbstractFactory.ChooseFactory("1").GetProductB().Dump();
AbstractFactory.ChooseFactory("2").GetProductA().Dump();
AbstractFactory.ChooseFactory("2").GetProductB().Dump();
}
// Define other methods and classes here
public interface IProductA{void ShowA();}
public interface IProductB{void ShowB();}
public class Product1A:IProductA
{
public void ShowA(){"Product1A".Dump();}
}
public class Product1B:IProductB
{
public void ShowB(){"Product1B".Dump();}
}
public class Product2A:IProductA
{
public void ShowA(){"Product2A".Dump();}
}
public class Product2B:IProductB
{
public void ShowB(){"Product2B".Dump();}
}
public abstract class AbstractFactory
{
public static AbstractFactory ChooseFactory(string name)
{
switch(name)
{
case "1":return new Factory1();
case "2":return new Factory2();
default:return null;
}
}
public abstract IProductA GetProductA();//因为不能确定产生哪个产品 所以返回接口
public abstract IProductB GetProductB();
}
public class Factory1:AbstractFactory
{
public override IProductA GetProductA(){return new Product1A();}
public override IProductB GetProductB(){return new Product1B();}
}
public class Factory2:AbstractFactory
{
public override IProductA GetProductA(){return new Product2A();}
public override IProductB GetProductB(){return new Product2B();}
}