Erzählen Sie vom Prinzip der Abhängigkeiten in SOLID, das dem Buchstaben D entspricht.

Prinzip der Dependency Inversion (Dependency Inversion Principle, DIP).

Hochrangige Module sollten nicht von niedrigstufigen Modulen abhängen. Beide sollten von Abstraktionen abhängen. Abstraktionen sollten nicht von Details abhängen. Details sollten von Abstraktionen abhängen.

Ziel des Prinzips: Reduzierung der Kopplung zwischen Komponenten, um das System flexibler, testbarer und skalierbarer zu machen.

Beispiel in Swift:

Schlecht:

class UserRepository {
    func getAllUsers() -> [User] {
        // Logik zum Abrufen von Benutzern aus einer bestimmten Datenbank oder Netzwerk
        // ...Implementierung...
        return []
    }
}

class UserService {
    private let repository = UserRepository() // Direkte Abhängigkeit von einer konkreten Implementierung

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

Gut (mit DIP):

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

// Niedrigstufiges Modul (Implementierung der Abstraktion)
class ConcreteUserRepository: UserRepositoryProtocol {
    func getAllUsers() -> [User] {
        // Logik zum Abrufen von Benutzern (Implementierungsdetails)
        // ...Implementierung...
        return []
    }
}

// Hochrangiges Modul, das von der Abstraktion abhängt
class UserService {
    private let repository: UserRepositoryProtocol // Abhängigkeit von der Abstraktion

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

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

// Zusammenstellung der Abhängigkeiten (besser in einem DI-Container)
let repository = ConcreteUserRepository()
let userService = UserService(repository: repository)

Hier hängt UserService (hochrangiges Modul) nicht direkt von ConcreteUserRepository (niedrigstufiges Modul) ab, sondern von der Abstraktion UserRepositoryProtocol. ConcreteUserRepository hängt ebenfalls von der Abstraktion ab, indem es sie implementiert. Die Abhängigkeit "invertiert" sich — anstatt dass das hochrangige Modul vom niedrigstufigen Modul abhängt, hängen beide von der Abstraktion ab.