第二节 控制反转和依赖注入

从前有一个这样的业务

代码编号01 需求：在MSSQLServer数据库中添加订单信息

step 1 构建MSSQLServer环境，有添加功能

public class MSSQLServer
{
public void Insert(){...}
}

setp 2 构建订单服务，向MSSQLServer环境添加数据

public class OrderService
{
private MSSQLServer _mssqlServer;

public Order(MSSQLServer mssqlServer)
{
_mssqlServer = mssqlServer;
}

public void Add()
{
_mssqlServer.Insert();
}
}

setp 3 整体贯通，实现需求

static void Main()
{
var mssqlServer= new MSSQLServer();
var orderService = new OrderService(mssqlServer);
orderService.Insert();
}

一个蠢萌的员工是这样修改的

代码编号04 需求：改造代码编号01的代码如下

step 1 构建MSSQLServer环境，有添加功能

public class MSSQLServer
{
public void Insert(){...}
}

setp 2 构建订单服务，向MSSQLServer环境添加数据

public class OrderService
{
private MSSQLServer _mssqlServer;

public Order()
{
//变化点：_mssqlServer在OrderService中创建对象
_mssqlServer = new MSSQLServer();
}

public void Add()
{
_mssqlServer.Insert();
}
}

setp 3 整体贯通，实现需求

static void Main()
{
var orderService = new OrderService();
orderService.Insert();
}

Leader是这样评价的

首先，代码01和04都能实现原有的业务功能。

其次，这样的业务实现必然需要数据存储的对象_mssqlServer。01中的_mssqlServer是在OrderService外创建，由构造中传入引用并使用的。04中的_mssqlServer是在OrderService内部创建并使用。相比起来，04不仅需要实现自身的业务，还需要构建需要用到的存储对象。

举个例子来说，你要造房子，在造之前需要一个梯子爬到屋顶。你需要直接拿来梯子用，不需要自己再建造个梯子，额外的工作量。

04 的代码中_mssqlServer是OrderService中new来创建的，01的代码只是传入使用，在外部创建就是控制反转。

控制反转IOC

控制反转：依赖的对象不在依赖使用的内部创建的。这里的依赖指的就是需要。

造房子需要的梯子、榔头就是依赖的对象。

大牛总结为：

控制反转（IoC），它为相互依赖的组件提供抽象，将依赖（低层模块）对象的获得交给第三方（系统）来控制，即依赖对象不在被依赖模块的类中直接通过new来获取。

依赖注入DI

当理解了IOC后，发现依赖的对象是外部创建并传入的，前辈们把这种传入叫做了注入，并总结了注入有3种形式。

构造注入

setp 2 构建订单服务，向MSSQLServer环境添加数据

public class OrderService
{
private MSSQLServer _mssqlServer;

//依赖的_mssqlServer通过构造中获得引用
public Order(MSSQLServer mssqlServer)
{
_mssqlServer = mssqlServer;
}

public void Add()
{
_mssqlServer.Insert();
}
}

setp 3 整体贯通，实现需求

static void Main()
{
var mssqlServer= new MSSQLServer();
var orderService = new OrderService(mssqlServer);
orderService.Insert();
}

属性注入

setp 2 构建订单服务，向MSSQLServer环境添加数据

public class OrderService
{
private MSSQLServer _mssqlServer;
public MSSQLServer SqlServerObject
{
get{
return _mssqlServer;
}
set{
//依赖的_mssqlServer通过属性中获得引用
_mssqlServer = value;
}
}

public void Add()
{
_mssqlServer.Insert();
}
}

setp 3 整体贯通，实现需求

static void Main()
{
var mssqlServer= new MSSQLServer();
var orderService = new OrderService();
orderService.SqlServerObject = mssqlServer;
orderService.Insert();
}

接口注入

setp 2 添加接口，获得依赖的引用

public interface IOrderService
{
void SetDependence(MSSQLServer mssqlServer);
}

setp 4 构建订单服务，向MSSQLServer环境添加数据

public class OrderService : IOrderService
{
public void SetDependence(MSSQLServer mssqlServer)
{
_mssqlServer = mssqlServer;
}

public void Add()
{
_mssqlServer.Insert();
}
}

setp 5 整体贯通，实现需求

static void Main()
{
var mssqlServer= new MSSQLServer();
var orderService = new OrderService();
orderService.SetDependence(mssqlServer);
orderService.Insert();
}

总结

当理解了控制反转后，依赖注入就是想法让依赖的地方得到自己依赖的对象。

构造注入使用更多，接口注入倒是用的比较少。

public class OrderService
{
private IDataAccess _dataAccess;

public Order(IDataAccess dataAccess) //核心的一句
{
_dataAccess = dataAccess;
}

public void Add()
{
_dataAccess .Insert();
}
}

首先，需要的_dataAccess 是传入的，是控制反转。

其次，_dataAccess 是通过构造传入的是，是构造注入。

第三，_dataAccess直接使用，不需要创建，符合单一职责原则。

最后，_dataAccess 是依赖的对象，是抽象的接口类型，并不知道实现是MSSQLServer、MySql还是Oracel，是依赖倒置原则的实现。

设计原则是一种指导思想，指导思想是抽象的

IOC控制反转是DIP这种设计原则下的一种设计模式，是落地可见的

控制反转：依赖的对象外部创建

依赖注入：依赖的对象外部传入

IOC这种设计模式中提到，把依赖的对象交给第三方来创建，这就是为后面介绍AutoFac这种第三方框架的使用做铺垫。