设计模式六大原则：依赖倒置原则
====================================================================================
目录：
设计模式六大原则：单一职责原则：
设计模式六大原则：接口隔离原则：https://www.cnblogs.com/az4215/p/11481076.html
设计模式六大原则：依赖倒置原则：https://www.cnblogs.com/az4215/p/11462878.html
设计模式六大原则：里氏替换原则：https://www.cnblogs.com/az4215/p/11462828.html
设计模式六大原则：迪米特法则：https://www.cnblogs.com/az4215/p/11489748.html
设计模式六大原则：开闭原则：https://www.cnblogs.com/az4215/p/11489712.html
=====================================================================================
依赖倒置原则(dependence inversion principle)：
1、高层模块不应该依赖底层模块，二者都应该依赖抽象。
2、抽象不应该依赖细节，细节应该依赖抽象。
3、依赖倒置的中心思想是面向接口编程。
4、依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础搭建的架构要稳定的多。
5、使用接口或抽象类的目的是指定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类来完成。
经典案例：
三二班有个小明，想要学习c#，于是买了本《深入理解c#》进行学习。
1 internal class program
2 {
3 private static void main(string[] args)
4 {
5 xiaoming xm = new xiaoming();
6 xm.study(new csharp());
7 }
8 }
9
10 internal class csharp
11 {
12 public void showmsg()
13 {
14 console.writeline("《深入理解c#》");
15 }
16 }
17
18 internal class xiaoming
19 {
20 public void study(csharp csharp)
21 {
22 csharp.showmsg();
23 }
24 }
过了一段时间，小明觉得光学习一门太没有意思了。听说linux比较好玩，于是买了本《鸟哥的私房菜linux》。
1 internal class program
2 {
3 private static void main(string[] args)
4 {
5 xiaoming xm = new xiaoming();
6 xm.study(new csharp());
7 xm.study(new linux());
8 }
9 }
10
11 internal class csharp
12 {
13 public void showmsg()
14 {
15 console.writeline("《深入理解c#》");
16 }
17 }
18
19 internal class linux
20 {
21 public void showmsg()
22 {
23 console.writeline("《鸟哥的私房菜linux》");
24 }
25 }
26
27 internal class xiaoming
28 {
29 public void study(csharp csharp)
30 {
31 csharp.showmsg();
32 }
33
34 public void study(linux linux)
35 {
36 linux.showmsg();
37 }
38 }
小明是一个聪明的娃，过了一段时间学得差不多了，于是又想学习《设计模式》...就这样小明在不断学习中成长，而我们的代码却越来越臃肿，变得难以维护。由于xiaoming是一个高级模块并且是一个细节实现类，此类依赖了书籍csharp和linux又是一个细节依赖类，这导致xiaoming每读一本书都需要修改代码，这与我们的依赖倒置原则是相悖的。那如何解决xiaoming的这种问题呢？
1 internal class program
2 {
3 private static void main(string[] args)
4 {
5 xiaoming xm = new xiaoming();
6 xm.study(new csharp());
7 xm.study(new linux());
8 }
9 }
10
11 internal interface ibook
12 {
13 void showmsg();
14 }
15
16 internal class csharp : ibook
17 {
18 public void showmsg()
19 {
20 console.writeline("《深入理解c#》");
21 }
22 }
23
24 internal class linux : ibook
25 {
26 public void showmsg()
27 {
28 console.writeline("《鸟哥的私房菜linux》");
29 }
30 }
31
32 internal class xiaoming
33 {
34 public void study(ibook book)
35 {
36 book.showmsg();
37 }
38 }
我们发现，只要让xiaoming依赖于抽象ibook，其他书籍依赖于该抽象，以后不管小明读什么书，哈哈都是so easy的。
依赖关系传递的三种方式：
1、通过接口传递(上述示例)
1 internal class xiaoming
2 {
3 // 2.通过接口传递依赖对象
4 public void study(ibook book)
5 {
6 book.showmsg();
7 }
8 }
2、通过构造方法传递
1 internal class xiaoming
2 {
3 private ibook _book;
4
5 // 1.通过构造函数传递依赖对象
6 public xiaoming(ibook book)
7 {
8 this._book = book;
9 }
10
11 public void study()
12 {
13 this._book.showmsg();
14 }
15 }
3、通过setter方法传递
1 internal class xiaoming
2 {
3 private ibook _book;
4
5 // 3.通过setter方法传递依赖对象
6 public void setbook(ibook _book)
7 {
8 this._book = _book;
9 }
10
11 public void study()
12 {
13 this._book.showmsg();
14 }
15 }
依赖倒置原则的本质就是通过抽象(接口或抽象类)使各个类或模块的实现彼此独立，不互相影响，实现模块间的松耦合。我们在项目中使用这个原则要遵循下面的规则：
1、每个类尽量都有接口或者抽象类，或者抽象类和接口两都具备
2、变量的表面类型尽量是接口或者抽象类
3、任何类都不应该从具体类派生
4、尽量不要覆写基类的方法
5、如果基类是一个抽象类，而这个方法已经实现了，子类尽量不要覆写。类间依赖的是抽象，覆写了抽象方法，对依赖的稳定性会有一定的影响
6、结合里氏替换原则使用