C#高级--设计模式（七个原则）

一、单一职责原则

原理：

单一职责原则即：对于一个类而言，应该仅有一个引起他变化的原因。换言之，一个类只负责一个功能领域中的相应职责。

单一职责原则是实现高内聚、低耦合的指导方针，它是最简单但又最难运用的原则，其难点和重点在于发现职责，并把这些职责相互分离，即区分职责的粒度问题。

总而言之，就是一个类中，只负责一件事，只有一个引起变更的原因。

单一职责的好处是：

好处一：提高代码的可读性，提高系统的可维护性

好处二：降低类的复杂度，一个模块只负责一个职责，提高系统的可拓展性和可维护性。

好处三：降低变更引起的风险。变更是必然的。如果单一职责做的更好，当修改一个功能的时候可以显著降低对另一个功能的影响。

二、开放封闭原则

原理：

1、对扩展开放，对修改关闭。其目的即：提高代码可复用性和可维护性。尽量少地去改动已有的模块，尤其是底层模块。

2、在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级，可以通过使用接口和抽象类达到这样的效果。

其精神所在即：面向需求，对程序的改动是通过添加新代码进行的而不是更改现有代码。不更改抽象层而可修改系统实现层。

三、里氏替换原则

原理：

1、任何基类可以出现的地方，子类一定可以出现，即：子类型必须能够替换掉其父类型。

2、LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。

3、LSP是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范

四、依赖倒置原则

原理：

1.高层模块不应该依赖于低层模块，两者都应以来抽象；

2.抽象不应该依赖于细节，细节应该依赖与抽象。

简单的说就是要求对抽象进行编程，不要对实现进行编程，这里的抽象即抽象类和接口。

依赖倒置原则的本质就是通过抽象（接口或抽象类）使各个类或模块的实现彼此独立，互不影响，

实现模块间的松耦合。

关于依赖

1、⼀一个优秀的⾯面向对象程序设计，核⼼心的原则之⼀一就是将变化「隔离」/「封装」，
使得变化部分发⽣生变化时，其他部分，不不受影响。
2、为了了实现这个⽬目的，需要使⽤用⾯面向接⼝口编程，使⽤用后，客户类，不不再直接依赖服务类，
⽽而是依赖⼀一个抽象的接⼝口，这样，客户类就不不能在内部直接实例例化服务类。
3、但是客户类在运⾏行行的过程中，⼜又需要具体的服务类来提供服务，因为接⼝口是不不能实例例化的，
就产⽣生了了⼀一个⽭矛盾：客户类不不允许实例例化服务类，但是客户类⼜又需要服务类的服务。
4、为了了解决这个⽭矛盾，我们设计了了⼀一种解决⽅方案，既：客户类定义⼀一个注⼊入点，⽤用于服务类的注⼊入，
⽽而客户类的客户类（Program类）负责根据情况，实例例化服务类，注⼊入到客户类中，从⽽而解决了了这个⽭矛盾。

依赖倒置代码案例如下所示：

namespace Program_依赖倒置原则
{internal class Program{static void Main(string[] args){//歌手歌唱不同国家的歌曲Singer singer = new Singer();singer.SingSongChinese(new ChinenseSong());singer.SingSongChinese(new JapaneseSong());Console.ReadKey();}}interface ISong{string SingSong();}class ChinenseSong:ISong{public string SingSong(){return "我在唱中文歌";}}class KoreaSong : ISong{public string SingSong(){return "韩国歌曲";}}class JapaneseSong : ISong{public string SingSong(){return "日本歌曲";}}class Singer{//调用者和被调用者之间是强耦合的关系//使用抽象封装变化//  通过抽象，使各个模块或者类的实现彼此独立，互不影响，实现模块间的松耦合public void SingSongChinese(ISong cs){Console.WriteLine("正在唱"+cs.SingSong());}}
}

五、接口隔离原则

原理：

1、客户端不应该依赖他不需要的接口。

2、一个类对另一个类的依赖应该建立在最小接口上

3、接口尽量细分不要一个接口中放多种方法。

它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

代码案例：

namespace Program_接口分离原则
{internal class Program{static void Main(string[] args){}}interface IScore{//修改某个学生的成绩void ChangeScore();}//接口要符合高内聚//接口要符合单一职责原则//还要实现类权限的问题，对接口中的方法进行分类细分interface ISuperScore{void AddScore();//删除某个学生的成绩void DeleteScore();}interface IQueryScore{void QueryScore();}class Teacher:IScore,IQueryScore{public void AddScore() { }public void DeleteScore() { }public void QueryScore() { }public void ChangeScore(){}}class Student : IQueryScore{public void QueryScore(){throw new NotImplementedException();}}
}

六、迪米特原则

原理：

1、它要求一个对象对其他对象有最少的了解（最少知识原则）。

2、降低类之间的耦合、

3、迪米特法则实际上是一个类在创建方法和属性时要遵守的法则。

迪米特法则强调，在类的结构设计上，尽量降低成员的访问权限。

其根本思想即强调了类之间的松耦合。 一般来说，类之间的耦合越弱，越有利于复用，一个处于弱耦合的类被修改，不会对关系类造成波及。

案例打印总公司员工和分公司员工信息：

namespace Program_迪米特原则
{internal class Program{static void Main(string[] args){//总公司员工类：ID//总公司员工管理类//添加总公司员工//打印总公司每个员工//打印分公司每个员工//分公司员工类//分公司管理类HeadEmployeeManager headEmployeeManager = new HeadEmployeeManager();headEmployeeManager.PrintEmployee();Console.ReadKey();}class HeadEmployee{public int ID { get; set; }}class HeadEmployeeManager{//总公司员工集合private List<HeadEmployee> headEmployee = new List<HeadEmployee>();//添加总公司员工public List<HeadEmployee> AddHeadEmployees(){for(int i = 0; i < 10; i++){headEmployee.Add(new HeadEmployee {  ID = i+1 });}return headEmployee;}public void PrintEmployee(){this.AddHeadEmployees();//打印总公司员工Console.WriteLine("===========================以下是总公司员工的编号==========================");for (int i = 0;i<headEmployee.Count;i++){Console.WriteLine(headEmployee[i].ID);}Console.WriteLine("==========================以下是分公司员工的编号============================");//打印分公司员工//创建分公司员工管理类的对象BodyEmployeeManager bodyEmployeeManager = new BodyEmployeeManager();//调用AddBodyEmployee添加分公司成员，并获取返回值List<BodyEmployee> listBodyEmployees = bodyEmployeeManager.AddBodyEmployees();for(int i = 0; i < listBodyEmployees.Count;i++){Console.WriteLine(listBodyEmployees[i].ID);}}}//分公司class BodyEmployee{public int ID { get; set; }}class BodyEmployeeManager{private List<BodyEmployee> bodyEmployees = new List<BodyEmployee>();public List<BodyEmployee> AddBodyEmployees(){for(int i = 0; i < 5; i++){bodyEmployees.Add(new BodyEmployee {  ID = i+1 });}return bodyEmployees;}}}
}

七、合成复用原则

原理：

1.合成复用原则，又称为组合聚合复用原则。

2.尽量使用对象组合，而不是继承来达到复用。

3.合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

继承带来的问题：

1.破坏了系统的封装性，基类发生了改变，子类的实现也会发生改变。

2.子类如果不需要Method3，则系统的耦合性变高。

3.继承使静态的不能在程序运行时发生改变。

合成复用具体情况实施代码：

namespace Program_复合复用原则
{internal class Program{static void Main(string[] args){//继承问题://可能造成子类泛滥//可能会造成子类数量爆炸//打破了类的封装性//创建油车对象GasCar gascar = new GasCar(new RedColor());gascar.Move();Console.ReadKey();}}interface IColor{string GetColor();}class WhiteColor : IColor{public string GetColor(){return "我是白色的汽车";}}class BlackColor : IColor{public string GetColor(){return "我是黑色的汽车";}}class RedColor : IColor{public string GetColor(){return "我是红色的汽车";}}abstract class Car{public IColor color { get; set; }public Car(IColor Color)//组合，强拥有关系{this.color = Color;}public abstract void Move();}class GasCar : Car{public GasCar(IColor color) : base(color){}public override void Move(){Console.WriteLine(this.color.GetColor()+"的电动汽车");}}class ElectricCar : Car{public ElectricCar(IColor Color) : base(Color){}public override void Move() {Console.WriteLine(this.color.GetColor()+"的汽油汽车");}}
}