依赖倒置原则的包含如下的三层含义：
高层模块不应该依赖低层模块，两者都应该依赖其抽象
抽象不应该依赖细节
细节应该依赖抽象
就是面向接口编程，采用依赖倒置原则可以减少类间的耦合性，提高系统的稳定性，降低并行开发引起的风险，提高代码的可读性和可维护性。
举个例子，小明开奔驰车。
我们需要两个底层模块，司机类，奔驰车类。以及调用其二者的高层模块
正常来写是这样子的：
Program.cs：
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class Program { static void Main(string[] args) { Driver driver = new Driver(); Benzn benzn = new Benzn(); driver.drive(benzn); Console.ReadLine(); } } }
Driver.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class Driver { public void drive(Benzn benzn) { Console.WriteLine("我是司机小明"); benzn.run(); } } }
Benzn.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class Benzn { public void run() { Console.WriteLine("奔驰车开始运行……"); } } }
以上的代码就完成了要求。
但是现在又买了一辆车，奥迪。又请了一位司机小王。那这个程序像上边那样写就有问题了，底层模块需要添加一个类，底层模块Driver需要更改（满足小明可以开奔驰、奥迪）高层（调用）模块需要更改。需要更改的地方太多。结构设计的不合理。
那我们现在根据依赖倒转原则来设计程序（面向接口编程）：
定义一个司机接口，一个汽车接口。
IDriver：
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { interface IDriver { void drive(ICar car); } }
ICar.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { interface ICar { void run(); } }
Program.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class Program { static void Main(string[] args) { IDriver driver = new Driver(); ICar benzn = new Benzn(); driver.drive(benzn); Console.ReadLine(); } } }
Benzn.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class Benzn:ICar { public void run() { Console.WriteLine("奔驰车开始运行……"); } } }
IDriver.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class Driver:IDriver { public void drive(ICar car) { Console.WriteLine("我是司机小明"); car.run(); } } }
DriverNew.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class DriverNew:IDriver { public void drive(ICar car) { Console.WriteLine("我是司机小王"); car.run(); } } }
Aodi.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dip { class Aodi:ICar { public void run() { Console.WriteLine("奥迪车开始运行……"); } } }
程序结构这样设计有一个好处，就是新增加汽车及司机都不需要修改底层模块Driver，只要新增一个底层模块类就好了，修改高层模块(业务场景类)，可以把"变更"的风险降低到最低。
抽象是对实现的约束，是对依赖者的一种契约，不仅仅约束自己，还同时约束自己与外部的关系，其目的就是保证所有的细节不脱离契约的范畴，确保约束双方按照规定好的契约(抽象)共同发展，只要抽象这条线还在，细节就脱离不了这个圈圈。就好比一场篮球比赛，已经定好了规则，大家如果按照规则来打球，那么会很愉快。但是假如大家脱离了规则，那么也许比赛就无法顺利进行。
深入理解
依赖倒置原则的本质就是通过抽象(抽象类或接口)使各个类或模块实现彼此独立，不互相影响，实现模块间的松耦合。在项目中使用这个规则需要以下原则; 每个类尽量都要有接口或抽象类，或者抽象类和接口都有： 依赖倒置原则的基本要求，有抽象才能依赖倒置 变量的表面类型尽量是接口或者抽象类 任何类都不应该从具体类派生 尽量不要重写基类已经写好的方法(里式替换原则) 结合里式替换原则来使用： 结合里式替换原则和依赖倒置原则我们可以得出一个通俗的规则，接口负责定义public属性和方法，并且声明与其他对象的依赖关系，抽象类负责公共构造部分的实现，实现类准确的实现业务逻辑，同时在适当的时候对父类进行细化。
