依赖倒置原则(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 }

view code

　　过了一段时间，小明觉得光学习一门太没有意思了。听说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 }

view code

　 小明是一个聪明的娃，过了一段时间学得差不多了，于是又想学习《设计模式》...就这样小明在不断学习中成长，而我们的代码却越来越臃肿，变得难以维护。由于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 }

view code

　　我们发现，只要让XiaoMing依赖于抽象IBook，其他书籍依赖于该抽象，以后不管小明读什么书，哈哈都是so easy的。

依赖关系传递的三种方式：

　　1、通过接口传递(上述示例) 

1 internal class XiaoMing
2 {
3     // 2.通过接口传递依赖对象
4     public void Study(IBook book)
5     {
6         book.ShowMsg();
7     }
8 }

view code

　　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 }

view code

　　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 }

view code

依赖倒置原则的本质就是通过抽象(接口或抽象类)使各个类或模块的实现彼此独立，不互相影响，实现模块间的松耦合。我们在项目中使用这个原则要遵循下面的规则：

　　1、每个类尽量都有接口或者抽象类，或者抽象类和接口两都具备

　　2、变量的表面类型尽量是接口或者抽象类

　　3、任何类都不应该从具体类派生

　　4、尽量不要覆写基类的方法

　　5、如果基类是一个抽象类，而这个方法已经实现了，子类尽量不要覆写。类间依赖的是抽象，覆写了抽象方法，对依赖的稳定性会有一定的影响

　　6、结合里氏替换原则使用