Vertel over het afhankelijkheidsprincipe in SOLID, dat overeenkomt met de letter D.

Principe van afhankelijkheidsomkering (Dependency Inversion Principle, DIP).

Hogere modules mogen niet afhankelijk zijn van lagere modules. Beide moeten afhankelijk zijn van abstracties. Abstracties mogen niet afhankelijk zijn van details. Details moeten afhankelijk zijn van abstracties.

Het doel van het principe: de koppeling tussen componenten verminderen, waardoor het systeem flexibeler, testbaarder en schaalbaarder wordt.

Voorbeeld in Swift:

Slecht:

class UserRepository {
    func getAllUsers() -> [User] {
        // Logica om gebruikers op te halen uit een specifieke database of netwerk
        // ...implementatie...
        return []
    }
}

class UserService {
    private let repository = UserRepository() // Directe afhankelijkheid van een concrete implementatie

    func fetchUsers() -> [User] {
        return repository.getAllUsers()
    }
}

Goed (met DIP):

// Abstractie
protocol UserRepositoryProtocol {
    func getAllUsers() -> [User]
}

// Laag niveau module (implementatie van de abstractie)
class ConcreteUserRepository: UserRepositoryProtocol {
    func getAllUsers() -> [User] {
        // Logica om gebruikers op te halen (implementatiedetails)
        // ...implementatie...
        return []
    }
}

// Hoog niveau module dat afhankelijk is van de abstractie
class UserService {
    private let repository: UserRepositoryProtocol // Afhankelijkheid van de abstractie

    init(repository: UserRepositoryProtocol) {
        self.repository = repository // Dependency injection
    }

    func fetchUsers() -> [User] {
        return repository.getAllUsers()
    }
}

// Afhankelijkheden samenstellen (beter in een DI-container)
let repository = ConcreteUserRepository()
let userService = UserService(repository: repository)

Hier hangt UserService (hoog niveau) niet direct af van ConcreteUserRepository (laag niveau), maar van de abstractie UserRepositoryProtocol. ConcreteUserRepository hangt ook van de abstractie en implementeert deze. De afhankelijkheid wordt "omgekeerd" — in plaats van dat het hoge niveau afhankelijk is van het lage niveau, hangen beide af van de abstractie.