依赖倒置原则(Dependence Inversion Principle)：
1、高层模块不应该依赖底层模块，二者都应该依赖抽象。
2、抽象不应该依赖细节，细节应该依赖抽象。
3、依赖倒置的中心思想是面向接口编程。
4、依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础搭建的架构要稳定的多。
5、使用接口或抽象类的目的是指定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类来完成。
经典案例：
三二班有个小明，想要学习C#，于是买了本《深入理解C#》进行学习。
internal class Program
{
private static void Main(string[] args)
{
XiaoMing xm = new XiaoMing();
xm.Study(new CSharp());
}
}
internal class CSharp
{
public void ShowMsg()
{
Console.WriteLine("《深入理解C#》");
}
}
internal class XiaoMing
{
public void Study(CSharp cSharp)
{
cSharp.ShowMsg();
}
}
过了一段时间，小明觉得光学习一门太没有意思了。听说Linux比较好玩，于是买了本《鸟哥的私房菜Linux》。
internal class Program
{
private static void Main(string[] args)
{
XiaoMing xm = new XiaoMing();
xm.Study(new CSharp());
xm.Study(new Linux());
}
}
internal class CSharp
{
public void ShowMsg()
{
Console.WriteLine("《深入理解C#》");
}
}
internal class Linux
{
public void ShowMsg()
{
Console.WriteLine("《鸟哥的私房菜Linux》");
}
}
internal class XiaoMing
{
public void Study(CSharp cSharp)
{
cSharp.ShowMsg();
}
public void Study(Linux linux)
{
linux.ShowMsg();
}
}
小明是一个聪明的娃，过了一段时间学得差不多了，于是又想学习《设计模式》...就这样小明在不断学习中成长，而我们的代码却越来越臃肿，变得难以维护。由于XiaoMing是一个高级模块并且是一个细节实现类，此类依赖了书籍CSharp和Linux又是一个细节依赖类，这导致XiaoMing每读一本书都需要修改代码，这与我们的依赖倒置原则是相悖的。那如何解决XiaoMing的这种问题呢？
internal class Program
{
private static void Main(string[] args)
{
XiaoMing xm = new XiaoMing();
xm.Study(new CSharp());
xm.Study(new Linux());
}
}
internal interface IBook
{
void ShowMsg();
}
internal class CSharp : IBook
{
public void ShowMsg()
{
Console.WriteLine("《深入理解C#》");
}
}
internal class Linux : IBook
{
public void ShowMsg()
{
Console.WriteLine("《鸟哥的私房菜Linux》");
}
}
internal class XiaoMing
{
public void Study(IBook book)
{
book.ShowMsg();
}
}
我们发现，只要让XiaoMing依赖于抽象IBook，其他书籍依赖于该抽象，以后不管小明读什么书，哈哈都是so easy的。
依赖关系传递的三种方式：
1、通过接口传递(上述示例)
internal class XiaoMing
{
// 2.通过接口传递依赖对象
public void Study(IBook book)
{
book.ShowMsg();
}
}
2、通过构造方法传递
internal class XiaoMing
{
private IBook _book;
// 1.通过构造函数传递依赖对象
public XiaoMing(IBook book)
{
this._book = book;
}
public void Study()
{
this._book.ShowMsg();
}
}
3、通过Setter方法传递
internal class XiaoMing
{
private IBook _book;
// 3.通过Setter方法传递依赖对象
public void setBook(IBook _book)
{
this._book = _book;
}
public void Study()
{
this._book.ShowMsg();
}
}
依赖倒置原则的本质
就是通过抽象(接口或抽象类)使各个类或模块的实现彼此独立，不互相影响，实现模块间的松耦合。我们在项目中使用这个原则要遵循下面的规则：
1、每个类尽量都有接口或者抽象类，或者抽象类和接口两都具备
2、变量的表面类型尽量是接口或者抽象类
3、任何类都不应该从具体类派生
4、尽量不要覆写基类的方法
5、如果基类是一个抽象类，而这个方法已经实现了，子类尽量不要覆写。类间依赖的是抽象，覆写了抽象方法，对依赖的稳定性会有一定的影响
6、结合里氏替换原则使用
