¿Cuál es la diferencia entre inversión de…

La inversión de dependencia (Principio de Inversión de Dependencias) es uno de los principios SOLID, que establece:

Los módulos de nivel superior no deben depender de los módulos de nivel inferior. Ambos deben depender de abstracciones.
Las abstracciones no deben depender de los detalles, los detalles deben depender de las abstracciones.

La inyección de dependencias (Dependency Injection, DI) es un patrón de diseño, una de las formas de implementar la inversión de dependencia. Implica pasar las dependencias (objetos de los que depende una clase) desde fuera, en lugar de que la clase las cree por sí misma.

Diferencias principales:

DIC - principio de diseño, DI - patrón de diseño.
DIC - define cómo deben ser las relaciones entre módulos de alto y bajo nivel (dependencia de abstracciones).
DI - método que permite implementar esas relaciones. Es una técnica concreta para suministrar dependencias a un objeto.

Ejemplos de inyección de dependencias:

Inyección por Constructor: Las dependencias se pasan a través del constructor.

// Swift
class UserFetcher {
    private let apiService: APIServiceProtocol // Dependencia de la abstracción

    init(apiService: APIServiceProtocol) { // Inyección a través del constructor
        self.apiService = apiService
    }

    func fetchUsers() {
        // uso de apiService
    }
}

protocol APIServiceProtocol {
    // ...
}

Inyección por Propiedad: Las dependencias se establecen a través de propiedades públicas (a menudo usando @IBOutlet o cuando la dependencia es opcional).

// Swift
class UserController: UIViewController {
    var userFetcher: UserFetcherProtocol? // Dependencia que puede ser establecida desde fuera

    override func viewDidLoad() {
        super.viewDidLoad()
        userFetcher?.fetchUsers()
    }
}

protocol UserFetcherProtocol {
    func fetchUsers()
}

Inyección por Método: Las dependencias se pasan como parámetros de métodos.

// Swift
class DataProcessor {
    func process(data: Data, using parser: DataParserProtocol) { // Dependencia pasada al método
        parser.parse(data)
    }
}

protocol DataParserProtocol {
    func parse(_ data: Data)
}

De esta manera, la inversión de dependencia es el objetivo (reducir el acoplamiento a través de abstracciones), y la inyección de dependencia es el medio (una de las formas de lograr ese objetivo).

¿Cuál es la diferencia entre inversión de dependencias y inyección de dependencias?