Parla del principio di dipendenza in SOLID, che corrisponde alla lettera D.

Principio di inversione delle dipendenze (Dependency Inversion Principle, DIP).

I moduli di alto livello non devono dipendere dai moduli di basso livello. Entrambi devono dipendere da astrazioni. Le astrazioni non devono dipendere dai dettagli. I dettagli devono dipendere dalle astrazioni.

Obiettivo del principio: ridurre l'accoppiamento tra i componenti, rendendo il sistema più flessibile, testabile e scalabile.

Esempio in Swift:

Cattivo:

class UserRepository {
    func getAllUsers() -> [User] {
        // Logica per ottenere utenti da un database o rete specifica
        // ...implementazione...
        return []
    }
}

class UserService {
    private let repository = UserRepository() // Dipendenza diretta da un'implementazione concreta

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

Buono (applicando DIP):

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

// Modulo di basso livello (implementazione dell'astrazione)
class ConcreteUserRepository: UserRepositoryProtocol {
    func getAllUsers() -> [User] {
        // Logica per ottenere utenti (dettagli di implementazione)
        // ...implementazione...
        return []
    }
}

// Modulo di alto livello che dipende dall'astrazione
class UserService {
    private let repository: UserRepositoryProtocol // Dipendenza dall'astrazione

    init(repository: UserRepositoryProtocol) {
        self.repository = repository // Iniezione di dipendenza
    }

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

// Assemblaggio delle dipendenze (meglio farlo in un contenitore DI)
let repository = ConcreteUserRepository()
let userService = UserService(repository: repository)

Qui, UserService (modulo di alto livello) non dipende direttamente da ConcreteUserRepository (modulo di basso livello), ma dipende dall'astrazione UserRepositoryProtocol. ConcreteUserRepository dipende anch'esso dall'astrazione, implementandola. La dipendenza si "inverte" — invece che il modulo di alto livello dipenda da quello di basso livello, entrambi dipendono dall'astrazione.