从前有一个这样的业务

代码编号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这种设计模式中提到，把依赖的对象交给第三方来创建，这就是为后面介绍AutoFac这种第三方框架的使用做铺垫。