Kun je een voorbeeld geven van de implementatie van het principe van afhankelijkheidsomkering in een project?

Het Dependency Inversion Principle (DIP) stelt dat hogere modules niet direct afhankelijk moeten zijn van lagere modules, maar dat beide afhankelijk moeten zijn van abstracties (bijvoorbeeld protocollen of interfaces).

Voorbeeld in Swift voor iOS:

// Abstractie
protocol DataService {
    func fetchData() -> String
}

// Concrete implementatie
class NetworkDataService: DataService {
    func fetchData() -> String {
        return "Gegevens van het netwerk"
    }
}

// Klasse die afhankelijk is van de abstractie, niet van de concrete implementatie
class ViewModel {
    private let dataService: DataService

    init(dataService: DataService) {
        self.dataService = dataService
    }

    func getData() -> String {
        return dataService.fetchData()
    }
}

// Gebruik
let networkService = NetworkDataService()
let viewModel = ViewModel(dataService: networkService)
print(viewModel.getData()) // Output: Gegevens van het netwerk

Hier hangt ViewModel af van het protocol DataService, niet van de concrete klasse NetworkDataService. Dit maakt het gemakkelijk om de implementatie van de service te wijzigen, bijvoorbeeld voor testen of een andere gegevensbron, zonder de code van ViewModel te wijzigen.