依赖倒置原则的包含如下的三层含义：
高层模块不应该依赖低层模块，两者都应该依赖其抽象抽象不应该依赖细节细节应该依赖抽象
就是面向接口编程，采用依赖倒置原则可以减少类间的耦合性，提高系统的稳定性，降低并行开发引起的风险，提高代码的可读性和可维护性。
举个例子，小明开奔驰车。
我们需要两个底层模块，司机类，奔驰车类。以及调用其二者的高层模块
正常来写是这样子的：
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属性和方法，并且声明与其他对象的依赖关系，抽象类负责公共构造部分的实现，实现类准确的实现业务逻辑，同时在适当的时候对父类进行细化。
有好的建议，请在下方输入你的评论。
欢迎访问个人博客
https://guanchao.site
