Povedzte o princípe závislosti v SOLID, ktorý zodpovedá písmenku D.

Princíp inverzie závislostí (Dependency Inversion Principle, DIP).

Moduly vysokého levelu by nemali závisieť od modulov nízkeho levelu. Oba by mali závisieť od abstrakcií. Abstrakcie by nemali závisieť od detailov. Detaily by mali závisieť od abstrakcií.

Cieľom princípu je znížiť prepojenie medzi komponentmi, čím sa systém stáva flexibilnejším, testovateľnejším a škálovateľnejším.

Príklad v Swift:

Zlé:

class UserRepository {
    func getAllUsers() -> [User] {
        // Logika na získanie používateľov z konkrétnej databázy alebo siete
        // ...implementácia...
        return []
    }
}

class UserService {
    private let repository = UserRepository() // Priama závislosť od konkrétnej implementácie

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

Dobré (s použitím DIP):

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

// Nízkoúrovňový modul (implementácia abstrakcie)
class ConcreteUserRepository: UserRepositoryProtocol {
    func getAllUsers() -> [User] {
        // Logika na získanie používateľov (detaily implementácie)
        // ...implementácia...
        return []
    }
}

// Vysokoúrovňový modul závisí od abstrakcie
class UserService {
    private let repository: UserRepositoryProtocol // Závislosť od abstrakcie

    init(repository: UserRepositoryProtocol) {
        self.repository = repository // Injektovanie závislosti
    }

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

// Skladanie závislostí (lepšie v DI konteineri)
let repository = ConcreteUserRepository()
let userService = UserService(repository: repository)

Tu UserService (vysoká úroveň) ne závisí priamo od ConcreteUserRepository (nízka úroveň), ale od abstrakcie UserRepositoryProtocol. ConcreteUserRepository tiež závisí od abstrakcie a ju implementuje. Závislosť sa "obracia" — namiesto toho, aby vysoká úroveň závisela od nízkej, obe závisia od abstrakcie.