0Pricing
Swift Academy · Leçon

Modèles de cas d’utilisation et de référentiel

Définir des cas d’utilisation sous forme de protocoles Swift et implémenter des interfaces de référentiel.

Modèles de cas d’utilisation et de référentiel est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Qu’est-ce qu’un cas d’utilisation ?

Un cas d’utilisation (interacteur) encapsule une action métier unique en orchestrant les entités du domaine et les dépôts.

struct PlaceOrderUseCase {
  let cart: CartRepository
  let payment: PaymentService
  let orders: OrderRepository
  func execute(userId: Int) async throws -> Order {
    let items = try await cart.items(for: userId)
    let receipt = try await payment.charge(items: items)
    return try await orders.create(receipt: receipt)
  }
}

Responsabilité unique

Chaque cas d’utilisation ne fait qu’une seule chose. Plusieurs responsabilités impliquent plusieurs cas d’utilisation.

// One use case per business action:
struct FetchUserUseCase { ... }
struct UpdateUserUseCase { ... }
struct DeleteUserUseCase { ... }

Le cas d’utilisation comme protocole

Définissez un protocole pour le cas d’utilisation afin de pouvoir le simuler dans les tests de la couche de présentation.

protocol PlacingOrder {
  func execute(userId: Int) async throws -> Order
}
struct PlaceOrderUseCase: PlacingOrder { ... }

Qu’est-ce qu’un dépôt ?

Un dépôt abstrait la source de données. Les appelants interagissent avec un protocole Swift ; l’implémentation peut utiliser le réseau, Core Data ou la mémoire.

protocol OrderRepository {
  func create(receipt: PaymentReceipt) async throws -> Order
  func list(userId: Int) async throws -> [Order]
  func cancel(orderId: Int) async throws
}

Implémentation d’un dépôt

Le dépôt concret traduit les appels du domaine en opérations réseau ou de base de données.

struct RemoteOrderRepository: OrderRepository {
  func create(receipt: PaymentReceipt) async throws -> Order {
    let dto = receipt.toDTO()
    let data = try await api.post("/orders", body: dto)
    return try JSONDecoder().decode(OrderDTO.self, from: data).toDomain()
  }
  func list(userId: Int) async throws -> [Order] { ... }
  func cancel(orderId: Int) async throws { ... }
}

Dépôt en mémoire pour les tests

Fournissez un dépôt en mémoire pour obtenir des tests rapides et déterministes, sans opérations d’entrée-sortie.

final class InMemoryOrderRepo: OrderRepository {
  var orders: [Order] = []
  func create(receipt: PaymentReceipt) async throws -> Order {
    let order = Order(id: orders.count + 1, items: receipt.items)
    orders.append(order)
    return order
  }
  func list(userId: Int) async throws -> [Order] { orders }
  func cancel(orderId: Int) async throws { orders.removeAll { $0.id == orderId } }
}

Composition des cas d’utilisation

Les cas d’utilisation peuvent appeler d’autres cas d’utilisation pour partager des sous-opérations, tout en gardant chaque cas ciblé.

struct CheckoutUseCase {
  let validateCart: ValidateCartUseCase
  let placeOrder: PlaceOrderUseCase
  let notifyUser: NotifyUserUseCase
  func execute(userId: Int) async throws -> Order {
    try await validateCart.execute(userId: userId)
    let order = try await placeOrder.execute(userId: userId)
    try await notifyUser.execute(order: order)
    return order
  }
}

Dépôt ou service

Dépôt : opérations CRUD sur un seul type d’entité. Service : orchestration de plusieurs entités ou appels à des API externes, sans stockage direct.

// Repository: single entity
protocol UserRepository { func getUser(id: Int) async throws -> User }
// Service: cross-entity operation
protocol AuthService { func login(email: String, password: String) async throws -> Session }

Mise en cache dans les dépôts

Les dépôts peuvent mettre les résultats en cache de manière transparente, sans que le cas d’utilisation connaisse ce détail d’implémentation.

struct CachedUserRepository: UserRepository {
  private var cache: [Int: User] = [:]
  private let remote: UserRepository
  func getUser(id: Int) async throws -> User {
    if let cached = cache[id] { return cached }
    let user = try await remote.getUser(id: id)
    cache[id] = user
    return user
  }
  func saveUser(_ user: User) async throws { try await remote.saveUser(user) }
}

Testabilité

Comme les cas d’utilisation dépendent de dépôts définis par des protocoles, vous pouvez injecter des doublures pour tester la logique métier de manière isolée.

let repo = InMemoryOrderRepo()
let sut = PlaceOrderUseCase(orders: repo, ...)
let order = try await sut.execute(userId: 1)
XCTAssertEqual(repo.orders.count, 1)

Traduction des erreurs

Les dépôts doivent convertir les erreurs de la couche de données (réseau, base de données) en erreurs du domaine avant de les renvoyer.

func getUser(id: Int) async throws -> User {
  do {
    let data = try await api.get("/users/\(id)")
    return try decode(data)
  } catch let e as URLError where e.code == .notConnectedToInternet {
    throw DomainError.offline
  }
}

Vérification rapide

Quelle est la différence essentielle entre un dépôt et un service dans l’architecture propre ?

Récapitulatif de la leçon

Les cas d’utilisation encapsulent des actions métier uniques et dépendent de protocoles de dépôt. Les dépôts abstraient les sources de données derrière un protocole. Utilisez des dépôts en mémoire pour des tests rapides. Les dépôts convertissent les erreurs de l’infrastructure en erreurs du domaine. Les services orchestrent les opérations portant sur plusieurs entités.

Questions Fréquemment Posées

La leçon « Modèles de cas d’utilisation et de référentiel » est-elle gratuite ?

Oui — le texte complet de « Modèles de cas d’utilisation et de référentiel » 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 « Modèles de cas d’utilisation et de référentiel » ?

Définir des cas d’utilisation sous forme de protocoles Swift et implémenter des interfaces de référentiel. 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 2 sur 4.

Combien de temps prend la leçon « Modèles de cas d’utilisation et de référentiel » ?

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