Kunt u het verschil uitleggen tussen de concepten Dependency Injection en Dependency Inversion in de context van softwareontwikkeling?

Dependency Injection (DI) — is een ontwerppatroon waarbij de afhankelijkheden van een object van buitenaf worden doorgegeven, in plaats van intern te worden gemaakt. Dit maakt het gemakkelijk om afhankelijkheidsimplementaties te wijzigen, vereenvoudigt testen en verhoogt de modulariteit van de code.

Inversie van afhankelijkheidsprincipe (DIP) — een van de vijf SOLID-principes, die stelt dat:

• Hoog-niveau modules niet afhankelijk moeten zijn van laag-niveau modules. Beide moeten afhankelijk zijn van abstracties.
• Abstracties mogen niet afhankelijk zijn van details. Details moeten afhankelijk zijn van abstracties.

Kort gezegd, DIP richt zich op het verminderen van de koppeling tussen componenten door gebruik te maken van abstracties (bijvoorbeeld interfaces).

Relatie tussen hen: DI is een manier om DIP te implementeren. Door DI te gebruiken, geven we afhankelijkheden door via de constructor of setters, waardoor modules afhankelijk worden van abstracties in plaats van concrete implementaties.

Voorbeeld in Swift:

protocol NetworkService {
    func fetchData()
}

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

class ViewModel {
    private let networkService: NetworkService

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

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

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

Hier, ViewModel is afhankelijk van de abstractie NetworkService (DIP), en de concrete implementatie wordt van buitenaf doorgegeven (DI).