Beszélj a SOLID-ben lévő függőségi elvről, amely megfelel a D betűnek.

Függőség fordított elv (Dependency Inversion Principle, DIP).

A magas szintű moduloknak nem szabad alacsony szintű moduloktól függniük. Mindkettőnek az absztrakcióktól kell függnie. Az absztrakciók nem szabad, hogy a részletektől függjenek. A részleteknek az absztrakcióktól kell függniük.

A principium célja: csökkenteni a komponensek közötti kötődést, ezáltal rugalmasabb, tesztelhetőbb és skálázhatóbb rendszert létrehozva.

Swift példán keresztül:

Rossz:

class UserRepository {
    func getAllUsers() -> [User] {
        // Logika a felhasználók lekéréséhez egy adott adatbázisból vagy hálózatból
        // ...megvalósítás...
        return []
    }
}

class UserService {
    private let repository = UserRepository() // Közvetlen függőség egy konkrét megvalósítástól

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

Jó (DIP alkalmazásával):

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

// Alsó szintű modul (az absztrakció megvalósítása)
class ConcreteUserRepository: UserRepositoryProtocol {
    func getAllUsers() -> [User] {
        // A felhasználók lekérésének logikája (megvalósítás részletei)
        // ...megvalósítás...
        return []
    }
}

// Magas szintű modul, amely az absztrakciótól függ
class UserService {
    private let repository: UserRepositoryProtocol // Függőség az absztrakciótól

    init(repository: UserRepositoryProtocol) {
        self.repository = repository // Dependencia injekció
    }

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

// Függőségek összerakása (jobb, ha DI konténerben történik)
let repository = ConcreteUserRepository()
let userService = UserService(repository: repository)

Itt a UserService (magas szintű modul) nem függ közvetlenül a ConcreteUserRepository-től (alacsony szintű modul), hanem az UserRepositoryProtocol absztrakciótól. A ConcreteUserRepository szintén az absztrakciótól függ és azt valósítja meg. A függőség "fordítva" van — ahelyett, hogy a magas szintű modul a mélyebb szintűtől függene, mindkettő az absztrakciótól függ.