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();}
}