Quelle est la différence entre inversion de…

L'inversion de dépendance (Principe d'Inversion de Dependances) est l'un des principes SOLID, qui stipule:

Les modules de niveau supérieur ne doivent pas dépendre des modules de niveau inférieur. Les deux doivent dépendre des abstractions.
Les abstractions ne doivent pas dépendre des détails, les détails doivent dépendre des abstractions.

L'injection de dépendances (Dependency Injection, DI) est un patron de conception, une des façons d'implémenter l'inversion de dépendance. Elle consiste à passer les dépendances (objets dont dépend une classe) de l'extérieur, plutôt que la classe ne les crée elle-même.

Principales différences:

DIC - principe de conception, DI - patron de conception.
DIC - définit comment doivent être les relations entre modules de haut et bas niveau (dépendance aux abstractions).
DI - méthode permettant d'implémenter ces relations. C'est une technique concrète pour fournir des dépendances à un objet.

Exemples d'injection de dépendances:

Injection par constructeur: Les dépendances sont passées via le constructeur.

// Swift
class UserFetcher {
    private let apiService: APIServiceProtocol // Dépendance à l'abstraction

    init(apiService: APIServiceProtocol) { // Injection via le constructeur
        self.apiService = apiService
    }

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

protocol APIServiceProtocol {
    // ...
}

Injection par propriété: Les dépendances sont établies via des propriétés publiques (souvent avec @IBOutlet ou si la dépendance est optionnelle).

// Swift
class UserController: UIViewController {
    var userFetcher: UserFetcherProtocol? // Dépendance pouvant être établie de l'extérieur

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

protocol UserFetcherProtocol {
    func fetchUsers()
}

Injection par méthode: Les dépendances sont passées en tant que paramètres de méthodes.

// Swift
class DataProcessor {
    func process(data: Data, using parser: DataParserProtocol) { // Dépendance passée à la méthode
        parser.parse(data)
    }
}

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

Ainsi, l'inversion de dépendance est l'objectif (réduction du couplage via des abstractions), et l'injection de dépendance est le moyen (une des façons d'atteindre cet objectif).

Quelle est la différence entre inversion de dépendances et injection de dépendances?