Pouvez-vous expliquer les différences entre les concepts d'Injection de Dépendances et d'Inversion de Dépendances dans le contexte du développement logiciel?

Injection de Dépendances (DI) — c'est un patron de conception dans lequel les dépendances d'un objet lui sont passées de l'extérieur, plutôt que d'être créées en interne. Cela permet de changer facilement les implémentations des dépendances, simplifie les tests et augmente la modularité du code.

Principe d'Inversion des Dépendances (DIP) — l'un des cinq principes SOLID, qui stipule que :

• Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Les deux doivent dépendre d'abstractions.
• Les abstractions ne doivent pas dépendre des détails. Les détails doivent dépendre des abstractions.

En termes simples, DIP vise à réduire le couplage entre les composants en utilisant des abstractions (par exemple, des interfaces).

Relation entre eux : DI est une façon de mettre en œuvre DIP. En utilisant DI, nous passons les dépendances via le constructeur ou des setters, ce qui permet aux modules de dépendre d'abstractions plutôt que d'implémentations concrètes.

Exemple en Swift :

protocol NetworkService {
    func fetchData()
}

class APIService: NetworkService {
    func fetchData() {
        print("Récupération des données de l'API")
    }
}

class ViewModel {
    private let networkService: NetworkService

    // Injection de dépendance via le constructeur
    init(networkService: NetworkService) {
        self.networkService = networkService
    }

    func load() {
        networkService.fetchData()
    }
}

let apiService = APIService()
let viewModel = ViewModel(networkService: apiService)
viewModel.load()

Ici, ViewModel dépend de l'abstraction NetworkService (DIP), et l'implémentation concrète est fournie de l'extérieur (DI).