1.概念
依赖倒置原则（Dependence Inversion Principle）是程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。
通俗的讲：
-
要面向抽象编程，而不是面向细节编程；
-
高层模块不应该依赖底层模块，二者应该通过抽象依赖，而不是依赖细节；
-
抽象不应该依赖于具体，具体应该依赖于抽象。
2.案例分析
需求：我们要开发一套自动驾驶系统，只要在汽车上安装该系统就可以实现自动驾驶，该系统目前只支持在福特和本田车上使用。
优化前版本（不满足依赖倒置原则）：
/// <summary>
/// 福特车
/// </summary>
public class FordCar
{
public void Run()
{
Console.WriteLine("福特开始启动了");
}
public void Turn()
{
Console.WriteLine("福特开始转弯了");
}
public void Stop()
{
Console.WriteLine("福特开始停车了");
}
}
/// <summary>
/// 本田车
/// </summary>
public class HondaCar
{
public void Run()
{
Console.WriteLine("本田开始启动了");
}
public void Turn()
{
Console.WriteLine("本田开始转弯了");
}
public void Stop()
{
Console.WriteLine("本田开始停车了");
}
}
/// <summary>
/// 自动驾驶
/// </summary>
public class AutoSystem
{
private HondaCar hcar = new HondaCar();
private FordCar fcar = new FordCar();
private CarType type;
public AutoSystem(CarType type)
{
this.type = type;
}
/// <summary>
/// 启动
/// </summary>
public void RunCar()
{
if (type == CarType.Ford)
{
fcar.Run();
}
else
{
hcar.Run();
}
}
/// <summary>
/// 转弯
/// </summary>
public void TurnCar()
{
if (type == CarType.Ford)
{
fcar.Turn();
}
else
{
hcar.Turn();
}
}
/// <summary>
/// 停车
/// </summary>
public void StopCar()
{
if (type == CarType.Ford)
{
fcar.Stop();
}
else
{
hcar.Stop();
}
}
public enum CarType : int
{
[Description("福特车")]
Ford = 0,
[Description("本田车")]
Honda = 1,
};
}
{
//DIP:依赖倒置原则
//福特车
AutoSystem fordAutoSystem = new AutoSystem(CarType.Ford);
fordAutoSystem.RunCar();
fordAutoSystem.TurnCar();
fordAutoSystem.StopCar();
//本田车
AutoSystem hondaAutoSystem = new AutoSystem(CarType.Honda);
hondaAutoSystem.RunCar();
hondaAutoSystem.TurnCar();
hondaAutoSystem.StopCar();
}
代码分析：
上面的程序确实能够实现针对Ford和Honda车的无人驾驶，但是在实际的生成场景中需求是不断变化的，比如我们现在又增加了一个新的合作伙伴：宝马车，那我们就需要新定义一个宝马车的实现类，以及对应的枚举CarType和上层的AutoSystem类都需要跟着修改，当随着越来越多的车企加入我们，那我们当前的设计就会变得僵化、脆弱。
如何优化？
导致上面所述问题的一个原因是：含有高层策略的utoSystem模块，依赖于它所控制的低层的具体细节的模块：HondaCar和FordCar。如果我们能够找到一种方法使AutoSystem模块独立于它所控制的具体细节，那么我们就可以自由地复用它了。我们就可以用这个模块来生成其它的程序，使得系统能够用在需要的汽车上。毋庸置疑那就该我们的依赖倒置原则出场了。
优化后的版本（满足依赖倒置原则）：
/// <summary>
/// 接口层
/// </summary>
public interface ICar
{
void Run();
void Turn();
void Stop();
}
/// <summary>
/// 福特车
/// </summary>
public class FordCarDIP : ICar
{
public void Run()
{
Console.WriteLine("福特开始启动了");
}
public void Turn()
{
Console.WriteLine("福特开始转弯了");
}
public void Stop()
{
Console.WriteLine("福特开始停车了");
}
}
/// <summary>
/// 本田车
/// </summary>
public class HondaCarDIP : ICar
{
public void Run()
{
Console.WriteLine("本田开始启动了");
}
public void Turn()
{
Console.WriteLine("本田开始转弯了");
}
public void Stop()
{
Console.WriteLine("本田开始停车了");
}
}
/// <summary>
/// 自动驾驶
/// </summary>
public class AutoSystemDIP
{
private ICar icar;
public AutoSystemDIP(ICar icar)
{
this.icar = icar;
}
/// <summary>
/// 启动
/// </summary>
public void RunCar()
{
icar.Run();
}
/// <summary>
/// 拐弯
/// </summary>
public void TurnCar()
{
icar.Turn();
}
/// <summary>
/// 停车
/// </summary>
public void StopCar()
{
icar.Stop();
}
}
{
//DIP:依赖倒置原则
//福特车
ICar car = new FordCarDIP();
AutoSystemDIP fordAutoSystem = new AutoSystemDIP(car);
fordAutoSystem.RunCar();
fordAutoSystem.TurnCar();
fordAutoSystem.StopCar();
//本田车
car = new HondaCarDIP();
AutoSystemDIP hondaAutoSystem = new AutoSystemDIP(car);
hondaAutoSystem.RunCar();
hondaAutoSystem.TurnCar();
hondaAutoSystem.StopCar();
}
代码分析：
AutoSystem系统依赖于ICar 这个抽象，而与具体的实现细节HondaCar、FordCar无关，所以实现细节的变化不会影响AutoSystem。对于实现细节只要实现ICar 即可，即实现细节依赖于ICar 抽象。
3.优缺点
优点：
-
降低类与类之间的耦合性；
-
增强系统的稳定性；
-
提高代码的可读性和维护性；
-
降低修改代码带来的风险；
缺点：
除了抽象难度大点、需要对功能业务理解透彻以外，几乎无缺点，依赖倒置还是我们开发中使用比较频繁的一个原则。
