Kunt u het verschil uitleggen tussen het principe van afhankelijkheidsomkering en afhankelijkheidsinjectie in programmeren?

Het Principe van Omkering van Afhankelijkheden (Dependency Inversion Principle, DIP) is een van de vijf SOLID-principes, dat stelt dat high-level modules niet direct afhankelijk moeten zijn van low-level modules, maar dat beide afhankelijk moeten zijn van abstracties (bijvoorbeeld interfaces). Abstracties moeten niet afhankelijk zijn van details, maar details moeten afhankelijk zijn van abstracties. Dit helpt om de architectuur flexibeler en gemakkelijk uitbreidbaar te maken.

Dependency Injection (DI) is een concreet patroon of techniek dat het principe van omkering van afhankelijkheden implementeert. DI betekent dat de afhankelijkheden van een object van buitenaf worden doorgegeven (bijvoorbeeld via de constructor, een setter of een methode), in plaats van binnen het object te worden gemaakt. Dit vergemakkelijkt testen en het vervangen van componenten.

In andere woorden:

• DIP is een regel of ontwerpprincipe.
• DI is een manier om dit principe in de praktijk te implementeren.

Voorbeeld in Swift:

protocol NetworkService {
    func fetchData()
}

class APIService: NetworkService {
    func fetchData() {
        print("Data ophalen van API")
    }
}

class ViewModel {
    let networkService: NetworkService

    // Dependency injection via de constructor
    init(networkService: NetworkService) {
        self.networkService = networkService
    }

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

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