Architecture SwiftUI
Quand utiliser cette compétence
Utilisez cette compétence lorsque :
- Vous avez de la logique dans vos fichiers de vue SwiftUI et souhaitez l'extraire
- Vous choisissez entre MVVM, TCA, les patrons SwiftUI vanilla, ou Coordinator
- Vous refactorisez des vues pour séparer les responsabilités
- Vous voulez rendre le code SwiftUI testable
- Vous vous demandez « où doit aller ce code ? »
- Vous décidez quel property wrapper utiliser (@State, @Environment, @Bindable)
- Vous organisez une base de code SwiftUI pour un développement en équipe
Exemples de requêtes
| Ce que vous pourriez demander | Pourquoi cette compétence aide |
|---|---|
| « Il y a pas mal de code dans mes fichiers de vue modèle concernant la logique. Comment l'extraire ? » | Fournit un workflow de refactorisation avec des arbres de décision pour savoir où placer la logique |
| « Dois-je utiliser MVVM, TCA ou les patrons vanilla d'Apple ? » | Critères de décision basés sur la complexité de l'app, la taille de l'équipe, les besoins de testabilité |
| « Comment rendre mon code SwiftUI testable ? » | Montre des patrons de séparation qui permettent le test sans imports SwiftUI |
| « Où placer les formateurs et les calculs ? » | La section anti-patrons empêche la logique dans les corps de vue |
| « Quel property wrapper dois-je utiliser ? » | Arbre de décision pour @State, @Environment, @Bindable, ou propriétés simples |
Arbre de décision rapide pour l'architecture
Qu'est-ce qui motive votre choix d'architecture ?
│
├─ Vous partez de zéro, appli petite/moyenne, vous voulez les patrons d'Apple ?
│ └─ Utilisez les Patrons Natifs d'Apple (Partie 1)
│ - Modèles @Observable pour la logique métier
│ - State-as-Bridge pour les frontières asynchrones
│ - Arbre de décision des property wrappers
│
├─ Vous connaissez MVVM depuis UIKit ?
│ └─ Utilisez le Patron MVVM (Partie 2)
│ - ViewModels comme adaptateurs de présentation
│ - Séparation claire View/ViewModel/Model
│ - Fonctionne bien avec @Observable
│
├─ Application complexe, besoin de testabilité rigoureuse, cohérence d'équipe ?
│ └─ Envisagez TCA (Partie 3)
│ - Architecture State/Action/Reducer/Store
│ - Excellente histoire de test
│ - Compromis courbe d'apprentissage + code boilerplate
│
└─ Navigation complexe, deep linking, points d'entrée multiples ?
└─ Ajoutez le Patron Coordinator (Partie 4)
- Peut être combiné avec n'importe lequel des précédents
- Extrait la logique de navigation des vues
- NavigationPath + objets Coordinator
Partie 1 : Patrons natifs d'Apple (iOS 26+)
Principe de base
« Un modèle de données assure la séparation entre les données et les vues qui interagissent avec elles. Cette séparation favorise la modularité, améliore la testabilité et facilite la compréhension du fonctionnement de l'application. » — Documentation développeur Apple
Les patrons SwiftUI modernes d'Apple (WWDC 2023-2025) sont centrés sur :
- @Observable pour les modèles de données (remplace ObservableObject)
- State-as-Bridge pour les frontières asynchrones (WWDC 2025)
- Trois property wrappers : @State, @Environment, @Bindable
- Mises à jour d'interface utilisateur synchrones pour les animations
Le patron State-as-Bridge
Problème
Les fonctions asynchrones créent des points de suspension qui peuvent casser les animations :
// ❌ Problématique : L'animation pourrait manquer la deadline de l'image
struct ColorExtractorView: View {
@State private var isLoading = false
var body: some View {
Button("Extract Colors") {
Task {
isLoading = true // Synchrone ✅
await extractColors() // ⚠️ Point de suspension !
isLoading = false // ❌ Pourrait arriver trop tard
}
}
.scaleEffect(isLoading ? 1.5 : 1.0) // ⚠️ Timing de l'animation incertain
}
}
Solution : Utiliser State comme un pont
« Trouvez les frontières entre le code d'interface utilisateur qui nécessite des changements sensibles au temps, et la logique asynchrone de longue durée. »
// ✅ Correct : State fait le pont entre l'interface utilisateur et le code asynchrone
@Observable
class ColorExtractor {
var isLoading = false
var colors: [Color] = []
func extract(from image: UIImage) async {
// Cette méthode est asynchrone et peut vivre dans le modèle
let extracted = await heavyComputation(image)
// Mutation synchrone pour la mise à jour de l'interface utilisateur
self.colors = extracted
}
}
struct ColorExtractorView: View {
let extractor: ColorExtractor
var body: some View {
Button("Extract Colors") {
// Changement d'état synchrone pour l'animation
withAnimation {
extractor.isLoading = true
}
// Lance le travail asynchrone
Task {
await extractor.extract(from: currentImage)
// Changement d'état synchrone pour l'animation
withAnimation {
extractor.isLoading = false
}
}
}
.scaleEffect(extractor.isLoading ? 1.5 : 1.0)
}
}
Avantages :
- La logique d'interface utilisateur reste synchrone (les animations fonctionnent correctement)
- Le code asynchrone vit dans le modèle (testable sans SwiftUI)
- Frontière claire entre l'interface utilisateur sensible au temps et le travail de longue durée
Arbre de décision des Property Wrappers
Il suffit de répondre à 3 questions :
Quel property wrapper dois-je utiliser ?
│
├─ Ce modèle doit-il être L'ÉTAT DE LA VUE ELLE-MÊME ?
│ └─ OUI → Utilisez @State
│ Exemples : Entrées de formulaire, toggles locaux, présentations de feuilles
│ Durée de vie : Gérée par la durée de vie de la vue
│
├─ Ce modèle doit-il faire partie de L'ENVIRONNEMENT GLOBAL ?
│ └─ OUI → Utilisez @Environment
│ Exemples : Compte utilisateur, paramètres de l'application, injection de dépendances
│ Durée de vie : Vit au niveau de l'application/scène
│
├─ Ce modèle a-t-il BESOIN DE BINDINGS UNIQUEMENT ?
│ └─ OUI → Utilisez @Bindable
│ Exemples : Édition d'un modèle passé par le parent
│ Léger : Active uniquement la syntaxe $ pour les bindings
│
└─ AUCUN DE CES CAS ?
└─ Utilisez comme propriété simple
Exemples : Données immuables, modèles possédés par le parent
Aucun wrapper nécessaire : @Observable gère l'observation
Exemples
// ✅ @State — La vue possède le modèle
struct DonutEditor: View {
@State private var donutToAdd = Donut() // État propre de la vue
var body: some View {
TextField("Name", text: $donutToAdd.name)
}
}
// ✅ @Environment — Modèle à l'échelle de l'application
struct MenuView: View {
@Environment(Account.self) private var account // Global
var body: some View {
Text("Bienvenue, \(account.userName)")
}
}
// ✅ @Bindable — A besoin de bindings vers un modèle possédé par le parent
struct DonutRow: View {
@Bindable var donut: Donut // Le parent le possède
var body: some View {
TextField("Name", text: $donut.name) // A besoin d'un binding
}
}
// ✅ Propriété simple — Juste pour la lecture
struct DonutRow: View {
let donut: Donut // Le parent le possède, pas besoin de binding
var body: some View {
Text(donut.name) // Juste pour la lecture
}
}
Patron de modèle @Observable
Utilisez @Observable pour la logique métier qui doit déclencher des mises à jour de l'interface utilisateur :
// ✅ Modèle de domaine avec logique métier
@Observable
class FoodTruckModel {
var orders: [Order] = []
var donuts = Donut.all
var orderCount: Int {
orders.count // Les propriétés calculées fonctionnent automatiquement
}
func addDonut() {
donuts.append(Donut())
}
}
// ✅ La vue suit automatiquement les propriétés accédées
struct DonutMenu: View {
let model: FoodTruckModel // Pas de wrapper nécessaire !
var body: some View {
List {
Section("Donuts") {
ForEach(model.donuts) { donut in
Text(donut.name) // Suit model.donuts
}
Button("Ajouter") {
model.addDonut()
}
}
Section("Commandes") {
Text("Nombre : \(model.orderCount)") // Suit model.orders
}
}
}
}
Comment ça fonctionne (WWDC 2023/10149) :
- SwiftUI suit quelles propriétés sont accédées pendant l'exécution du
body - Seules ces propriétés déclenchent des mises à jour de la vue lorsqu'elles sont modifiées
- Suivi granulaire des dépendances = meilleure performance
Patron ViewModel Adapter
Utilisez les ViewModels comme adaptateurs de présentation lorsque vous avez besoin de filtrage, de tri ou d'une logique spécifique à la vue :
// ✅ ViewModel comme adaptateur de présentation
@Observable
class PetStoreViewModel {
let petStore: PetStore // Modèle de domaine
var searchText: String = ""
// Propriété calculée spécifique à la vue
var filteredPets: [Pet] {
guard !searchText.isEmpty else { return petStore.myPets }
return petStore.myPets.filter { $0.name.contains(searchText) }
}
}
struct PetListView: View {
@Bindable var viewModel: PetStoreViewModel
var body: some View {
List {
ForEach(viewModel.filteredPets) { pet in
PetRowView(pet: pet)
}
}
.searchable(text: $viewModel.searchText)
}
}
Quand utiliser un ViewModel adaptateur :
- Filtrage, tri, regroupement pour l'affichage
- Mise en forme pour la présentation (mais PAS de calculs lourds)
- État spécifique à la vue qui n'appartient pas au modèle de domaine
- Faire le pont entre le modèle de domaine et les conventions SwiftUI
Quand NE PAS utiliser de ViewModel :
- Vues simples qui affichent juste les données du modèle
- Logique qui appartient au modèle de domaine
- Sur-extraction juste pour la « pureté du patron »
Partie 2 : Patron MVVM
Quand utiliser MVVM
MVVM (Model-View-ViewModel) est approprié lorsque :
✅ Vous le connaissez depuis UIKit — Intégration plus facile pour l'équipe ✅ Vous voulez une séparation explicite View/ViewModel — Contrats clairs ✅ Vous avez une logique de présentation complexe — Opérations multiples de filtrage/tri ✅ Vous migrez depuis UIKit — Modèle mental familier
❌ Évitez MVVM quand :
- Les vues sont simples (juste l'affichage de données)
- Vous partez de zéro avec SwiftUI (les patrons d'Apple sont plus simples)
- Vous créez des couches d'abstraction inutiles
Structure MVVM pour SwiftUI
// Model — Données de domaine et logique métier
struct Pet: Identifiable {
let id: UUID
var name: String
var kind: Kind
var trick: String
var hasAward: Bool = false
mutating func giveAward() {
hasAward = true
}
}
// ViewModel — Logique de présentation
@Observable
class PetListViewModel {
private let petStore: PetStore
var pets: [Pet] { petStore.myPets }
var searchText: String = ""
var selectedSort: SortOption = .name
var filteredSortedPets: [Pet] {
let filtered = pets.filter { pet in
searchText.isEmpty || pet.name.contains(searchText)
}
return filtered.sorted { lhs, rhs in
switch selectedSort {
case .name: lhs.name < rhs.name
case .kind: lhs.kind.rawValue < rhs.kind.rawValue
}
}
}
init(petStore: PetStore) {
self.petStore = petStore
}
func awardPet(_ pet: Pet) {
petStore.awardPet(pet.id)
}
}
// View — Interface utilisateur uniquement
struct PetListView: View {
@Bindable var viewModel: PetListViewModel
var body: some View {
List {
ForEach(viewModel.filteredSortedPets) { pet in
PetRow(pet: pet) {
viewModel.awardPet(pet)
}
}
}
.searchable(text: $viewModel.searchText)
}
}
Erreurs MVVM courantes dans SwiftUI
❌ Erreur 1 : Dupliquer @Observable dans la Vue et le ViewModel
// ❌ @State + @Observable est redondant — @State crée son propre stockage
struct MyView: View {
@State private var viewModel = MyViewModel() // ❌ Wrapper redondant
}
// ✅ Passez @Observable directement — utilisez @State uniquement si la vue POSSÈDE le cycle de vie
struct MyView: View {
let viewModel: MyViewModel // ✅ Ou @State si la vue le crée
}
❌ Erreur 2 : ViewModel fourre-tout
// ❌ Ne faites pas ceci
@Observable
class AppViewModel {
// Paramètres
var isDarkMode = false
var notificationsEnabled = true
// Utilisateur
var userName = ""
var userEmail = ""
// Contenu
var posts: [Post] = []
var comments: [Comment] = []
// ... 50 propriétés de plus
}
// ✅ Correct : Séparez les responsabilités
@Observable
class SettingsViewModel {
var isDarkMode = false
var notificationsEnabled = true
}
@Observable
class UserProfileViewModel {
var user: User
}
@Observable
class FeedViewModel {
var posts: [Post] = []
}
❌ Erreur 3 : Logique métier dans le ViewModel
// ❌ Les règles métier appartiennent au Model, pas au ViewModel
@Observable class OrderViewModel {
func calculateDiscount(for order: Order) -> Double { /* ... */ } // ❌ Logique métier
}
// ✅ Le Model possède la logique métier ; le ViewModel formate uniquement pour l'affichage
struct Order {
func calculateDiscount() -> Double { /* règles métier */ }
}
@Observable class OrderViewModel {
let order: Order
var displayDiscount: String {
"$\(order.calculateDiscount(), specifier: "%.2f")" // ✅ Juste du formatage
}
}
Partie 3 : TCA (Composable Architecture)
Quand envisager TCA
TCA est une architecture tierce de Point-Free. Envisagez-la lorsque :
✅ La testabilité rigoureuse est critique — TestStore rend les tests déterministes ✅ Une grande équipe a besoin de cohérence — Des patrons stricts réduisent la variabilité ✅ La gestion d'état complexe — Effets secondaires, dépendances, composition ✅ Vous appréciez les patrons Redux — Flux de données unidirectionnel
❌ Évitez TCA quand :
- Application petite ou prototype (trop de surcharge)
- L'équipe n'est pas familière avec la programmation fonctionnelle
- Vous avez besoin d'itérations rapides (le code boilerplate ralentit le développement)
- Vous voulez un minimum de dépendances
Concepts de base de TCA
TCA a 4 blocs de construction — State (données), Action (événements), Reducer (évolution de l'état), et Store (moteur d'exécution). Les voici dans une seule fonctionnalité :
// STATE — Données dont votre fonctionnalité a besoin
@ObservableState
struct CounterFeature {
var count = 0
var fact: String?
var isLoading = false
}
// ACTION — Tous les événements possibles
enum Action {
case incrementButtonTapped
case decrementButtonTapped
case factButtonTapped
case factResponse(String)
}
// REDUCER — Comment l'état évolue en réponse aux actions
struct CounterFeature: Reducer {
var body: some ReducerOf<Self> {
Reduce { state, action in
switch action {
case .incrementButtonTapped:
state.count += 1
return .none
case .decrementButtonTapped:
state.count -= 1
return .none
case .factButtonTapped:
state.isLoading = true
return .run { send in
let fact = await getFact(state.count)
await send(.factResponse(fact))
}
case let .factResponse(fact):
state.isLoading = false
state.fact = fact
return .none
}
}
}
}
// STORE — Le moteur d'exécution qui connecte tout
struct CounterView: View {
let store: StoreOf<CounterFeature>
var body: some View {
Form {
Text("\(store.count)")
HStack {
Button("-") { store.send(.decrementButtonTapped) }
Button("+") { store.send(.incrementButtonTapped) }
}
Button("Obtenir un fait") { store.send(.factButtonTapped) }
if let fact = store.fact {
Text(fact)
}
}
}
}
Test avec TCA
@Test
func testIncrement() async {
let store = await TestStore(initialState: CounterFeature()) {
CounterFeature()
}
await store.send(.incrementButtonTapped) {
$0.count = 1
}
}
@Test
func testFactFlow() async {
let store = await TestStore(initialState: CounterFeature()) {
CounterFeature()
} withDependencies: {
$0.factClient.fetch = { _ in "Un fait cool" }
}
await store.send(.factButtonTapped) {
$0.isLoading = true
}
await store.receive(\.factResponse) {
$0.isLoading = false
$0.fact = "Un fait cool"
}
}
Quand TCA est exagéré
// ❌ TCA pour un simple compteur — les patrons natifs d'Apple sont plus simples
struct CounterView: View {
@State private var count = 0
var body: some View {
Button("Compteur : \(count)") { count += 1 }
}
}
Partie 4 : Patron Coordinator
Quand ajouter un Coordinator
✅ Navigation complexe — Flux profonds, conditionnels ✅ Deep linking — États d'écran profonds via URL/notification ✅ Points d'entrée multiples — Widgets, raccourcis, différentes tabs ✅ Navigation réutilisable — Mêmes flux depuis différents endroits
❌ Évitez Coordinator quand :
- Application à onglets simples avec navigation linéaire
- Écrans hiérarchiques simples (push/pop)
- Moins de 5 écrans
Coordinator de base
@Observable
class AppCoordinator {
var path = NavigationPath()
var presentedSheet: Sheet?
enum Sheet: Hashable, Identifiable {
case settings
case createDonut
var id: Self { self }
}
func showSettings() {
presentedSheet = .settings
}
func showDonutDetail(_ donut: Donut) {
path.append(donut)
}
}
struct AppView: View {
@State private var coordinator = AppCoordinator()
var body: some View {
NavigationStack(path: $coordinator.path) {
HomeView(coordinator: coordinator)
.navigationDestination(for: Donut.self) { donut in
DonutDetailView(donut: donut, coordinator: coordinator)
}
}
.sheet(item: $coordinator.presentedSheet) { sheet in
switch sheet {
case .settings: SettingsView()
case .createDonut: CreateDonutView()
}
}
.environment(coordinator)
}
}
Anti-patrons des Coordinators
❌ Coordinator avec trop de responsabilités
// ❌ Ne faites pas cela
@Observable
class SuperCoordinator {
var path = NavigationPath()
var userSettings = UserSettings() // ❌ La gestion de l'utilisateur n'est pas de la navigation
var networkManager = NetworkManager() // ❌ Le réseau n'est pas de la navigation
func saveAndNavigate() { /* ... */ } // ❌ Trop de responsabilités
}
✅ Correct : Coordinator uniquement pour la navigation
@Observable
class AppCoordinator {
var path = NavigationPath() // Navigation uniquement
func navigateToOrders() { path.append(AppRoute.orders) }
func navigateToDonut(_ donut: Donut) { path.append(donut) }
}
// Les modèles de données et services sont séparés
Anti-patrons courants
❌ Logique dans le corps de la vue
// ❌ Évitez : Logique complexe dans le corps de la vue
struct DonutListView: View {
let donuts: [Donut]
@State private var searchText = ""
var body: some View {
List {
// ❌ Filtrage et tri logique ici
ForEach(donuts
.filter { $0.name.contains(searchText) }
.sorted { $0.name < $1.name }
) { donut in
DonutRow(donut: donut)
}
}
}
}
// ✅ Préférez : Propriété calculée ou modèle séparé
struct DonutListView: View {
let donuts: [Donut]
@State private var searchText = ""
var filteredSortedDonuts: [Donut] {
donuts
.filter { searchText.isEmpty || $0.name.contains(searchText) }
.sorted { $0.name < $1.name }
}
var body: some View {
List {
ForEach(filteredSortedDonuts) { donut in
DonutRow(donut: donut)
}
}
}
}
❌ Sur-extraction
// ❌ Évitez : Service pour une simple opération
class StringFormatterService {
func capitalize(_ string: String) -> String { string.capitalized }
}
struct GreetingView: View {
let formatter = StringFormatterService()
let name: String
var body: some View {
Text(formatter.capitalize("Bonjour, \(name)"))
}
}
// ✅ Préférez : Simple et direct
struct GreetingView: View {
let name: String
var body: some View {
Text("Bonjour, \(name)")
.textCase(.uppercase) // ✅ Utilisez directement SwiftUI
}
}
❌ Trop de ViewModels
// ❌ Évitez : ViewModel pour chaque vue, même les plus simples
struct ProfileHeaderView: View {
@Bindable var viewModel: ProfileHeaderViewModel
}
@Observable
class ProfileHeaderViewModel {
var user: User
// Ne fait rien d'autre que de contenir l'utilisateur
}
// ✅ Préférez : Vue simple avec modèle
struct ProfileHeaderView: View {
let user: User
var body: some View {
HStack {
AvatarView(user: user)
Text(user.name)
}
}
}
Liste de vérification pour la refactorisation
Utilisez cette liste lorsque vous extrayez la logique des vues :
- Le corps de la vue a-t-il moins de 20 lignes ?
- Y a-t-il des boucles
if,switch,forcomplexes dans la vue ? → Extraire - Les mises en forme et les calculs se trouvent-ils dans le corps de la vue ? → Extraire dans une propriété calculée ou un modèle
- La vue appelle-t-elle directement un service réseau ou une base de données ? → Déplacer dans un modèle
- La navigation est-elle intégrée dans la vue ? → Envisager un Coordinator
- La logique métier peut-elle être testée sans importer SwiftUI ? → Si non, extraire
- Les propriétés utilisent-elles le property wrapper le plus simple ? (@State si la vue possède, @Bindable si parent, etc.)
- L'architecture est-elle cohérente dans toute la base de code ?
- Un nouveau membre d'équipe peut-il comprendre la structure ?
- Avez-vous besoin de cette abstraction ? (Voir la section sur la sur-extraction)