设计模式（五）之依赖倒转原则

依赖倒置原则的包含如下的三层含义：

1.  高层模块不应该依赖低层模块，两者都应该依赖其抽象
   

2.  抽象不应该依赖细节
   

3.  细节应该依赖抽象
   

就是面向接口编程，采用依赖倒置原则可以减少类间的耦合性，提高系统的稳定性，降低并行开发引起的风险，提高代码的可读性和可维护性。

举个例子，小明开奔驰车。

我们需要两个底层模块，司机类，奔驰车类。以及调用其二者的高层模块

正常来写是这样子的：

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

欢迎访问小程序：