0Pricing
Swift Academy · Leçon

Inversion des dépendances avec des abstractions de protocoles

Dépendre d’abstractions plutôt que d’implémentations concrètes, en utilisant les protocoles Swift comme frontières.

Inversion des dépendances avec des abstractions de protocoles est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Principe d’inversion des dépendances

Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Les deux doivent dépendre d’abstractions (protocoles).

// WITHOUT DIP:
class OrderService { let db = SQLiteDatabase() }  // depends on concrete
// WITH DIP:
class OrderService { let db: Database }  // depends on abstraction

Définition de l’abstraction

Extrayez un protocole qui définit le contrat dont votre module de haut niveau a besoin.

protocol Database {
  func save<T: Encodable>(_ value: T, key: String) throws
  func load<T: Decodable>(key: String) throws -> T
}

Implémentations concrètes

Fournissez plusieurs implémentations concrètes derrière le protocole : production, test et futures alternatives.

class SQLiteDatabase: Database { ... }
class InMemoryDatabase: Database { ... }
class KeychainDatabase: Database { ... }

Injection par initialiseur

Transmettez l’abstraction par l’intermédiaire de l’initialiseur : c’est le style d’injection le plus explicite et le plus facile à tester.

class ProfileService {
  private let db: Database
  init(db: Database) { self.db = db }
}

Pourquoi ne pas utiliser des singletons partout ?

Les singletons globaux masquent les dépendances, ce qui rend le code difficile à tester et à comprendre.

// Hard to test:
class Service { func run() { MySingleton.shared.doWork() } }
// Easy to test:
class Service { let dep: MyProtocol; func run() { dep.doWork() } }

Abstractions par protocoles en Swift

Les protocoles Swift peuvent inclure des types associés, des implémentations par défaut et de la composition : ils sont idéaux pour des abstractions riches.

protocol Cacheable {
  associatedtype Key: Hashable
  associatedtype Value
  func get(_ key: Key) -> Value?
  func set(_ key: Key, value: Value)
}

Granularité des abstractions

Ségrégation des interfaces : préférez des protocoles restreints aux protocoles trop larges, afin que les implémentations ne fournissent que ce dont les appelants ont besoin.

// Fat (avoid):
protocol DataStore {
  func save(...); func load(...); func delete(...); func query(...); func migrate()
}
// Narrow (prefer):
protocol Readable { func load<T>(...) throws -> T }
protocol Writable { func save<T>(...) throws }

PRD avec Combine

Renvoyez AnyPublisher depuis les méthodes du protocole afin de masquer le type du diffuseur sous-jacent.

protocol UserStream {
  func userUpdates() -> AnyPublisher<User, Never>
}

PRD avec async/await

Les méthodes de protocole marquées async throws sont entièrement compatibles avec la concurrence structurée de Swift.

protocol Analytics {
  func track(event: String) async
}
struct FirebaseAnalytics: Analytics {
  func track(event: String) async { /* Firebase call */ }
}

PRD au niveau de l’application

Assemblez les implémentations concrètes au point d’entrée de l’application (racine de composition), en regroupant toutes les liaisons au même endroit.

@main
struct MyApp: App {
  let db: Database = SQLiteDatabase()
  let repo: UserRepository = RemoteUserRepository(db: db)
  let useCase = FetchUserUseCase(repo: repo)
  var body: some Scene {
    WindowGroup { ContentView(useCase: useCase) }
  }
}

Tests avec le PRD

Dans les tests, remplacez les implémentations réelles par des simulations ou des doublures au point d’injection.

let mockDB = InMemoryDatabase()
let service = ProfileService(db: mockDB)
// Exercise service
XCTAssertEqual(try mockDB.load(key: "profile"), expectedProfile)

Vérification rapide

Que stipule le principe d’inversion des dépendances à propos des modules de haut niveau ?

Récapitulatif de la leçon

PRD : les modules de haut niveau dépendent d’abstractions définies par des protocoles ; les types concrets les implémentent. Extrayez des protocoles restreints, injectez-les par les initialiseurs et assemblez tout à la racine de composition. Cela permet de remplacer les implémentations pour les tests, l’activation de fonctionnalités et les futurs besoins.

Questions Fréquemment Posées

La leçon « Inversion des dépendances avec des abstractions de protocoles » est-elle gratuite ?

Oui — le texte complet de « Inversion des dépendances avec des abstractions de protocoles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Inversion des dépendances avec des abstractions de protocoles » ?

Dépendre d’abstractions plutôt que d’implémentations concrètes, en utilisant les protocoles Swift comme frontières. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Inversion des dépendances avec des abstractions de protocoles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Couches : domaine, données et présentation
  2. Modèles de cas d’utilisation et de référentiel
  3. Inversion des dépendances avec des abstractions de protocoles
  4. Relier les couches sans framework DI
← Retour à Swift Academy