DI和IOC是两种主要侧重于提供组件之间的松耦合的设计模式，或者简单地说，这是一种解耦对象之间传统依赖关系的方法，这样对象之间就不会紧密相连。

通过下面的例子，我试图解释这两个概念。

以前我们是这样写代码的

Public MyClass{
 DependentClass dependentObject
 /*
  At somewhere in our code we need to instantiate 
  the object with new operator  inorder to use it or perform some method.
  */ 
  dependentObject= new DependentClass();
  dependentObject.someMethod();
}

使用Dependency注入，依赖注入器将负责对象的实例化

Public MyClass{
 /* Dependency injector will instantiate object*/
 DependentClass dependentObject

 /*
  At somewhere in our code we perform some method. 
  The process of  instantiation will be handled by the dependency injector
 */ 

  dependentObject.someMethod();
}

上述将控件交给其他容器(例如容器)进行实例化和注入的过程可以称为控制反转，IOC容器为我们注入依赖项的过程可以称为依赖项注入。

IOC是程序控制流颠倒过来的原则:不是由程序员控制程序的流，而是由程序通过减少程序员的开销来控制流程。程序用来注入依赖的过程称为DI

这两个概念一起工作为我们提供了一种编写更加灵活、可重用和封装的代码的方法，这使得它们在设计面向对象的解决方案时成为重要的概念。

也推荐阅读。

什么是依赖注入?

你也可以在这里查看我的一个类似的答案

控制反转和依赖注入的区别

IoC -控制反转是一个通用术语，与语言无关，它实际上不是创建对象，而是描述如何创建时尚对象。

依赖注入是一个具体的术语，我们通过使用不同的注入技术，即Setter注入、构造函数注入或接口注入，在运行时提供对象的依赖关系。

控制反转是一种设计范式，其目标是为应用程序的目标组件提供更多的控制，即完成工作的组件。 依赖注入是一种模式，用于创建其他对象所依赖的对象实例，而在编译时不知道将使用哪个类来提供该功能。

实现控制反转有几种基本技术。这些都是:

使用工厂模式 使用服务定位器模式 使用任何给定类型的依赖注入: 1).构造函数注入 2). setter注入 3).接口注入

关于这个问题，我想说维基已经提供了详细易懂的解释。我引用这里最重要的。

国际奥委会的实施

在面向对象编程中，有几种基本的技术来实现 实现控制反转。这些都是: 使用依赖注入，用于 构造函数注入参数注入Setter注入 接口注入; 使用上下文化查找; 采用模板法设计模式; 使用策略设计模式

至于依赖注入

依赖注入是一种技术，一个对象(或静态的 方法)提供了另一个对象的依赖关系。依赖关系是 可以使用的对象(服务)。注入是传递 对使用它的依赖对象(客户端)的依赖。

IOC(控制反转)基本上是一种设计模式概念，它删除依赖关系并将它们解耦，使流非线性，并让容器/或另一个实体管理依赖关系的供应。它实际上遵循了好莱坞的原则“不要打电话给我们，我们会打电话给你”。 总结一下不同点。

控制反转:这是一个通用术语，用于解耦依赖关系并委托它们的供应，这可以通过几种方式实现(事件，委托等)。

依赖注入:—DI是IOC的一种子类型，通过构造函数注入、setter注入或方法注入实现。

下面的文章对此进行了非常简洁的描述。

https://www.codeproject.com/Articles/592372/Dependency-Injection-DI-vs-Inversion-of-Control-IO

DIP vs DI vs IoC

[依赖倒置原则(DIP)]是SOLID[About]的一部分，它要求你使用抽象而不是实现

依赖注入(DI) -使用聚合而不是组合[关于]在这种情况下，外部对象负责内部的逻辑。哪一种方法使您拥有更动态和更可测试的方法

class A {
  B b

  //injecting B via constructor 
  init(b: B) {
     self.b = b
  }
}

控制反转(IoC)是一个非常高级的定义，它更多地是关于控制流的。最好的例子是控制反转(IoC)容器或框架。例如，GUI是一个框架，你没有一个控制，你能做的一切只是实现框架的接口，当一些动作发生在框架中时，它会被调用。这样，控制权就从应用程序转移到了正在使用的框架中

DIP +

class A {
  IB ib

  init(ib: IB) {
     self.ib = ib
  }
}

你也可以使用:

(工厂方法) (服务定位器) [ioc容器(框架)]

更复杂的例子

多层/模块结构中的依赖规则

伪代码:

interface InterfaceInputPort {
    func input()
}

interface InterfaceOutputPort {
    func output()
}

class A: InterfaceOutputPort {

    let inputPort = B(outputPort: self)

    func output() {
        print("output")
    }
}

class B: InterfaceInputPort {
    let outputPort: InterfaceOutputPort

    init(outputPort: InterfaceOutputPort) {
        self.outputPort = outputPort
    }

    func input() {
        print("input")
    }
}