Parlez du principe de dépendance dans SOLID, qui correspond à la lettre D.

Principe d'inversion des dépendances (Dependency Inversion Principle, DIP).

Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Les deux doivent dépendre d'abstractions. Les abstractions ne doivent pas dépendre des détails. Les détails doivent dépendre des abstractions.

Objectif du principe : réduire le couplage entre les composants, rendant le système plus flexible, testable et évolutif.

Exemple en Swift :

Mauvais :

class UserRepository {
    func getAllUsers() -> [User] {
        // Logique pour obtenir des utilisateurs d'une base de données ou réseau spécifique
        // ...implémentation...
        return []
    }
}

class UserService {
    private let repository = UserRepository() // Dépendance directe à une implémentation concrète

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

Bon (avec DIP) :

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

// Module de bas niveau (implémentation de l'abstraction)
class ConcreteUserRepository: UserRepositoryProtocol {
    func getAllUsers() -> [User] {
        // Logique pour obtenir des utilisateurs (détails de l'implémentation)
        // ...implémentation...
        return []
    }
}

// Module de haut niveau dépendant de l'abstraction
class UserService {
    private let repository: UserRepositoryProtocol // Dépendance à l'abstraction

    init(repository: UserRepositoryProtocol) {
        self.repository = repository // Injection de dépendance
    }

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

// Assemblage des dépendances (mieux dans un conteneur DI)
let repository = ConcreteUserRepository()
let userService = UserService(repository: repository)

Ici, UserService (module de haut niveau) ne dépend pas directement de ConcreteUserRepository (module de bas niveau), mais dépend de l'abstraction UserRepositoryProtocol. ConcreteUserRepository dépend également de l'abstraction, en la réalisant. La dépendance est "inversée" — au lieu que le module de haut niveau dépende du module de bas niveau, ils dépendent tous deux de l'abstraction.