Injection de dépendances en Swift : principes, exemples et implémentation

Qu'est-ce que l'Injection de Dépendances et pourquoi en a-t-on besoin en Swift

L'Injection de Dépendances (DI) est un pattern de conception dans lequel un objet reçoit ses dépendances de l'extérieur, plutôt que de les créer lui-même. Dans le contexte de Swift pour iOS et macOS, la DI aide à rendre le code plus flexible, testable et maintenable. Au lieu de lier rigidement les classes via init() ou let, vous transmettez les dépendances via le constructeur, une propriété ou une méthode.

Les principaux avantages de la DI :

• Testabilité : vous pouvez facilement remplacer les objets réels par des mocks ou des stubs dans les tests unitaires.
• Faible couplage : les classes dépendent d'abstractions (protocoles), et non d'implémentations concrètes.
• Simplification du refactoring : les modifications dans une partie du code n'en cassent pas une autre.
• Architecture propre : le code suit le principe de responsabilité unique et le principe d'inversion des dépendances (DIP de SOLID).

En Swift, la DI est particulièrement importante lors du travail avec UIKit, SwiftUI, CoreData, le réseau et d'autres services. Sans elle, vous risquez d'obtenir des "objets god" et des difficultés à réutiliser le code.

Les principales façons d'injecter des dépendances en Swift

1. Injection via l'initialiseur (Constructor Injection)

La méthode la plus courante et recommandée. Les dépendances sont transmises lors de la création de l'objet et deviennent immuables (let).

protocol NetworkServiceProtocol {    func fetchData() -> String}

class NetworkService: NetworkServiceProtocol {    func fetchData() -> String {        return "Данные с сервера"    }}

class ViewModel {    private let networkService: NetworkServiceProtocol

    // Внедрение через инициализатор    init(networkService: NetworkServiceProtocol) {        self.networkService = networkService    }

    func loadData() -> String {        return networkService.fetchData()    }}

// Использованиеlet service = NetworkService()let viewModel = ViewModel(networkService: service)print(viewModel.loadData()) // "Данные с сервера"

Avantages : dépendances explicites, l'objet est toujours dans un état valide. Inconvénient : avec un grand nombre de dépendances, le constructeur devient encombrant.

2. Injection via la propriété (Property Injection)

La dépendance est définie après la création de l'objet. Souvent utilisée pour les services optionnels ou lors du travail avec Storyboard/XIB.

class UserViewController: UIViewController {    var analyticsService: AnalyticsServiceProtocol?

    override func viewDidLoad() {        super.viewDidLoad()        analyticsService?.trackEvent("Экран открыт")    }}

// Внедрениеlet vc = UserViewController()vc.analyticsService = AnalyticsService()

Inconvénient : la propriété doit être optionnelle ou avoir une valeur par défaut, ce qui peut entraîner des erreurs d'exécution si vous oubliez de définir la dépendance.

3. Injection via la méthode (Method Injection)

La dépendance est transmise comme paramètre de méthode. Convient aux situations où la dépendance n'est nécessaire que pour une seule opération.

class DataManager {    func processData(using service: NetworkServiceProtocol) -> String {        let rawData = service.fetchData()        return "Обработано: \\(rawData)"    }}

let manager = DataManager()let result = manager.processData(using: NetworkService())print(result) // "Обработано: Данные с сервера"

Exemple d'implémentation de la DI dans une application iOS

Considérons un exemple concret : une application pour afficher une liste d'utilisateurs. Créons des protocoles et des classes avec injection de dépendances.

// 1. Протоколыprotocol UserRepositoryProtocol {    func getUsers() -> [String]}

protocol UserViewModelProtocol {    var users: [String] { get }    func loadUsers()}

// 2. Реализация репозиторияclass UserRepository: UserRepositoryProtocol {