Wat is het verschil tussen afhankelijkheidsomkering…

Dependancy Inversie (Dependency Inversion Principle) is een van de SOLID-principes, dat stelt:

Modules op hoog niveau mogen niet afhankelijk zijn van modules op laag niveau. Beide moeten afhankelijk zijn van abstracties.
Abstracties mogen niet afhankelijk zijn van details, details moeten afhankelijk zijn van abstracties.

Dependency Injection (DI) is een ontwerppatroon, een van de manieren om de inversie van afhankelijkheid te implementeren. Het houdt in dat afhankelijkheden (objecten waarvan een klasse afhankelijk is) van buitenaf worden doorgegeven, in plaats van dat de klasse ze zelf creëert.

Belangrijkste verschillen:

DIC - ontwerpprincipe, DI - ontwerppatroon.
DIC - bepaalt hoe de relaties tussen high-level en low-level modules moeten zijn (afhankelijkheid van abstracties).
DI - methode die deze relaties mogelijk maakt. Het is een concrete techniek om afhankelijkheden aan een object te leveren.

Voorbeelden van afhankelijkheidsinjectie:

Constructor Injectie: Afhankelijkheden worden via de constructor doorgegeven.

// Swift
class UserFetcher {
    private let apiService: APIServiceProtocol // Afhankelijkheid van abstractie

    init(apiService: APIServiceProtocol) { // Injectie via constructor
        self.apiService = apiService
    }

    func fetchUsers() {
        // gebruik van apiService
    }
}

protocol APIServiceProtocol {
    // ...
}

Property Injectie: Afhankelijkheden worden ingesteld via openbare eigenschappen (vaak met @IBOutlet of wanneer de afhankelijkheid optioneel is).

// Swift
class UserController: UIViewController {
    var userFetcher: UserFetcherProtocol? // Afhankelijkheid die van buitenaf kan worden ingesteld

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

protocol UserFetcherProtocol {
    func fetchUsers()
}

Method Injectie: Afhankelijkheden worden als parameters aan methoden doorgegeven.

// Swift
class DataProcessor {
    func process(data: Data, using parser: DataParserProtocol) { // Afhankelijkheid wordt aan de methode doorgegeven
        parser.parse(data)
    }
}

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

Op deze manier is de afhankelijkheidsomkering het doel (het verminderen van koppeling via abstracties), en dependency injection is het middel (een van de manieren om dat doel te bereiken).

Wat is het verschil tussen afhankelijkheidsomkering en afhankelijkheidsinjectie?