SwiftUI-Architektur
Wann diese Fähigkeit verwendet werden sollte
Verwenden Sie diese Fähigkeit, wenn:
- Sie Logik in Ihren SwiftUI-View-Dateien haben und diese extrahieren möchten
- Sie zwischen MVVM, TCA, Vanilla-SwiftUI-Mustern oder Coordinator wählen
- Sie Views umgestalten, um Belange zu trennen
- Sie SwiftUI-Code testbar machen möchten
- Sie fragen: "Wo soll dieser Code hin?"
- Sie entscheiden, welchen Property Wrapper Sie verwenden sollen (@State, @Environment, @Bindable)
- Sie eine SwiftUI-Codebasis für die Teamarbeit organisieren
Beispiel-Prompts
| Was Sie fragen könnten | Warum diese Fähigkeit hilft |
|---|---|
| "In meinen Model-View-Dateien gibt es ziemlich viel Code zu Logik-Themen. Wie extrahiere ich ihn?" | Bietet einen Refactoring-Workflow mit Entscheidungsbäumen, wohin die Logik gehört |
| "Sollte ich MVVM, TCA oder die Vanilla-Muster von Apple verwenden?" | Entscheidungskriterien basierend auf App-Komplexität, Teamgröße, Testbarkeitsanforderungen |
| "Wie mache ich meinen SwiftUI-Code testbar?" | Zeigt Trennungsmuster, die Tests ohne SwiftUI-Imports ermöglichen |
| "Wo sollen Formatierungen und Berechnungen hin?" | Der Abschnitt Anti-Patterns verhindert Logik in View-Bodies |
| "Welchen Property Wrapper verwende ich?" | Entscheidungsbaum für @State, @Environment, @Bindable oder einfache Eigenschaften |
Schnell-Entscheidungsbaum für die Architektur
Was treibt Ihre Architekturwahl an?
│
├─ Sie beginnen neu, kleine/mittlere App, möchten Apples Muster?
│ └─ Verwenden Sie Apples native Muster (Teil 1)
│ - @Observable-Modelle für Geschäftslogik
│ - State-as-Bridge für asynchrone Grenzen
│ - Entscheidungsbaum für Property Wrapper
│
├─ Sie kennen MVVM von UIKit?
│ └─ Verwenden Sie das MVVM-Muster (Teil 2)
│ - ViewModels als Präsentationsadapter
│ - Klare Trennung von View/ViewModel/Model
│ - Funktioniert gut mit @Observable
│
├─ Komplexe App, strenge Testbarkeit, Teamkonsistenz erforderlich?
│ └─ Ziehen Sie TCA in Betracht (Teil 3)
│ - State/Action/Reducer/Store-Architektur
│ - Hervorragende Testmöglichkeiten
│ - Lernkurve vs. Boilerplate-Kompromiss
│
└─ Komplexe Navigation, Deep Linking, mehrere Einstiegspunkte?
└─ Fügen Sie das Coordinator-Muster hinzu (Teil 4)
- Kann mit allen oben genannten kombiniert werden
- Extrahiert Navigationslogik aus Views
- NavigationPath + Coordinator-Objekte
Teil 1: Apples native Muster (iOS 26+)
Kernprinzip
"Ein Datenmodell bietet eine Trennung zwischen den Daten und den Views, die mit den Daten interagieren. Diese Trennung fördert Modularität, verbessert die Testbarkeit und hilft, das Verständnis dafür zu erleichtern, wie die App funktioniert." — Apple-Entwicklerdokumentation
Apples moderne SwiftUI-Muster (WWDC 2023–2025) konzentrieren sich auf:
- @Observable für Datenmodelle (ersetzt ObservableObject)
- State-as-Bridge für asynchrone Grenzen (WWDC 2025)
- Drei Property Wrapper: @State, @Environment, @Bindable
- Synchrone UI-Updates für Animationen
Das State-as-Bridge-Muster
Problem
Asynchrone Funktionen erzeugen Unterbrechungspunkte, die Animationen stören können:
// ❌ Problematisch: Animation könnte Frame-Frist verpassen
struct ColorExtractorView: View {
@State private var isLoading = false
var body: some View {
Button("Farben extrahieren") {
Task {
isLoading = true // Synchron ✅
await extractColors() // ⚠️ Unterbrechungspunkt!
isLoading = false // ❌ Könnte zu spät passieren
}
}
.scaleEffect(isLoading ? 1.5 : 1.0) // ⚠️ Animationszeitpunkt unsicher
}
}
Lösung: Verwenden Sie State als Brücke
"Finden Sie die Grenzen zwischen UI-Code, der zeitkritische Änderungen erfordert, und langlebiger asynchroner Logik."
// ✅ Korrekt: State überbrückt UI und asynchronen Code
@Observable
class ColorExtractor {
var isLoading = false
var colors: [Color] = []
func extract(from image: UIImage) async {
// Diese Methode ist asynchron und kann im Modell leben
let extracted = await heavyComputation(image)
// Synchrone Mutation für UI-Update
self.colors = extracted
}
}
struct ColorExtractorView: View {
let extractor: ColorExtractor
var body: some View {
Button("Farben extrahieren") {
// Synchrone Zustandsänderung für Animation
withAnimation {
extractor.isLoading = true
}
// Asynchrone Arbeit starten
Task {
await extractor.extract(from: currentImage)
// Synchrone Zustandsänderung für Animation
withAnimation {
extractor.isLoading = false
}
}
}
.scaleEffect(extractor.isLoading ? 1.5 : 1.0)
}
}
Vorteile:
- UI-Logik bleibt synchron (Animationen funktionieren korrekt)
- Asynchroner Code lebt im Modell (testbar ohne SwiftUI)
- Klare Grenze zwischen zeitkritischer UI und langlebiger Arbeit
Entscheidungsbaum für Property Wrapper
Es gibt nur 3 Fragen zu beantworten:
Welchen Property Wrapper soll ich verwenden?
│
├─ Muss dieses Modell ein ZUSTAND DER VIEW SELBST sein?
│ └─ JA → Verwenden Sie @State
│ Beispiele: Formulareingaben, lokale Umschalter, Sheet-Präsentationen
│ Lebensdauer: Verwaltet durch die Lebensdauer der View
│
├─ Muss dieses Modell Teil der GLOBALEN UMGEBUNG sein?
│ └─ JA → Verwenden Sie @Environment
│ Beispiele: Benutzerkonto, App-Einstellungen, Abhängigkeitsinjektion
│ Lebensdauer: Lebt auf App-/Scene-Ebene
│
├─ Benötigt dieses Modell NUR BINDUNGEN?
│ └─ JA → Verwenden Sie @Bindable
│ Beispiele: Bearbeiten eines von der übergeordneten View übergebenen Modells
│ Leichtgewichtig: Aktiviert nur die $-Syntax für Bindungen
│
└─ NICHTS DAVON?
└─ Verwenden Sie es als einfache Eigenschaft
Beispiele: Unveränderliche Daten, von der übergeordneten View besessene Modelle
Kein Wrapper erforderlich: @Observable übernimmt die Beobachtung
Beispiele
// ✅ @State — View besitzt das Modell
struct DonutEditor: View {
@State private var donutToAdd = Donut() // Eigener Zustand der View
var body: some View {
TextField("Name", text: $donutToAdd.name)
}
}
// ✅ @Environment — App-weites Modell
struct MenuView: View {
@Environment(Account.self) private var account // Global
var body: some View {
Text("Willkommen, \(account.userName)")
}
}
// ✅ @Bindable — Benötigt Bindungen zu einem von der übergeordneten View besessenen Modell
struct DonutRow: View {
@Bindable var donut: Donut // Übergeordnete View besitzt es
var body: some View {
TextField("Name", text: $donut.name) // Benötigt Bindung
}
}
// ✅ Einfache Eigenschaft — Nur lesen
struct DonutRow: View {
let donut: Donut // Übergeordnete View besitzt, keine Bindung erforderlich
var body: some View {
Text(donut.name) // Nur lesen
}
}
Das @Observable-Modell-Muster
Verwenden Sie @Observable für Geschäftslogik, die UI-Updates auslösen muss:
// ✅ Domänenmodell mit Geschäftslogik
@Observable
class FoodTruckModel {
var orders: [Order] = []
var donuts = Donut.all
var orderCount: Int {
orders.count // Berechnete Eigenschaften funktionieren automatisch
}
func addDonut() {
donuts.append(Donut())
}
}
// ✅ View verfolgt automatisch aufgerufene Eigenschaften
struct DonutMenu: View {
let model: FoodTruckModel // Kein Wrapper erforderlich!
var body: some View {
List {
Section("Donuts") {
ForEach(model.donuts) { donut in
Text(donut.name) // Verfolgt model.donuts
}
Button("Hinzufügen") {
model.addDonut()
}
}
Section("Bestellungen") {
Text("Anzahl: \(model.orderCount)") // Verfolgt model.orders
}
}
}
}
Wie es funktioniert (WWDC 2023/10149):
- SwiftUI verfolgt, welche Eigenschaften während der Ausführung von
bodyaufgerufen werden - Nur diese Eigenschaften lösen View-Updates aus, wenn sie geändert werden
- Granulare Abhängigkeitsverfolgung = bessere Leistung
ViewModel-Adapter-Muster
Verwenden Sie ViewModels als Präsentationsadapter, wenn Sie Filter-, Sortier- oder Viewspezifische Logik benötigen:
// ✅ ViewModel als Präsentationsadapter
@Observable
class PetStoreViewModel {
let petStore: PetStore // Domänenmodell
var searchText: String = ""
// Viewspezifische berechnete Eigenschaft
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)
}
}
Wann ein ViewModel-Adapter verwendet werden sollte:
- Filtern, Sortieren, Gruppieren für die Anzeige
- Formatieren für die Präsentation (aber KEINE schweren Berechnungen)
- Viewspezifischer Zustand, der nicht in das Domänenmodell gehört
- Brücke zwischen Domänenmodell und SwiftUI-Konventionen
Wann KEIN ViewModel verwendet werden sollte:
- Einfache Views, die nur Modelldaten anzeigen
- Logik, die in das Domänenmodell gehört
- Übermäßige Extraktion nur aus "Musterreinheit"
Teil 2: MVVM-Muster
Wann MVVM verwendet werden sollte
MVVM (Model-View-ViewModel) ist geeignet, wenn:
✅ Sie es von UIKit kennen — Einfachere Einarbeitung für das Team ✅ Sie eine explizite View/ViewModel-Trennung wünschen — Klare Verträge ✅ Sie komplexe Präsentationslogik haben — Mehrere Filter-/Sortiervorgänge ✅ Sie von UIKit migrieren — Vertrautes mentales Modell
❌ MVVM vermeiden, wenn:
- Views einfach sind (nur Daten anzeigen)
- Sie frisch mit SwiftUI beginnen (Apples Muster sind einfacher)
- Sie unnötige Abstraktionsebenen erstellen
MVVM-Struktur für SwiftUI
// Model — Domänendaten und Geschäftslogik
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 — Präsentationslogik
@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 — Nur UI
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)
}
}
Häufige MVVM-Fehler in SwiftUI
❌ Fehler 1: @Observable in View und ViewModel duplizieren
// ❌ @State + @Observable ist redundant — @State erzeugt seinen eigenen Speicher
struct MyView: View {
@State private var viewModel = MyViewModel() // ❌ Redundanter Wrapper
}
// ✅ @Observable direkt übergeben — @State nur verwenden, wenn die View den LEBENSZYKLUS BESITZT
struct MyView: View {
let viewModel: MyViewModel // ✅ Oder @State, wenn die View es erstellt
}
❌ Fehler 2: Gott-ViewModel
// ❌ Nicht so machen
@Observable
class AppViewModel {
// Einstellungen
var isDarkMode = false
var notificationsEnabled = true
// Benutzer
var userName = ""
var userEmail = ""
// Inhalt
var posts: [Post] = []
var comments: [Comment] = []
// ... 50 weitere Eigenschaften
}
// ✅ Korrekt: Belange trennen
@Observable
class SettingsViewModel {
var isDarkMode = false
var notificationsEnabled = true
}
@Observable
class UserProfileViewModel {
var user: User
}
@Observable
class FeedViewModel {
var posts: [Post] = []
}
❌ Fehler 3: Geschäftslogik im ViewModel
// ❌ Geschäftsregeln gehören in das Modell, nicht in das ViewModel
@Observable class OrderViewModel {
func calculateDiscount(for order: Order) -> Double { /* ... */ } // ❌ Geschäftslogik
}
// ✅ Das Modell besitzt die Geschäftslogik; das ViewModel formatiert nur für die Anzeige
struct Order {
func calculateDiscount() -> Double { /* Geschäftsregeln */ }
}
@Observable class OrderViewModel {
let order: Order
var displayDiscount: String {
"$\(order.calculateDiscount(), specifier: "%.2f")" // ✅ Nur Formatierung
}
}
Teil 3: TCA (Composable Architecture)
Wann TCA in Betracht gezogen werden sollte
TCA ist eine Drittanbieter-Architektur von Point-Free. Ziehen Sie sie in Betracht, wenn:
✅ Strenge Testbarkeit ist kritisch — TestStore macht Tests deterministisch ✅ Ein großes Team benötigt Konsistenz — Strenge Muster reduzieren Abweichungen ✅ Komplexes Zustandsmanagement — Nebenwirkungen, Abhängigkeiten, Komposition ✅ Sie mögen Redux-ähnliche Muster — Unidirektionaler Datenfluss
❌ TCA vermeiden, wenn:
- Kleine App oder Prototyp (zu viel Overhead)
- Team mit funktionaler Programmierung nicht vertraut
- Sie schnelle Iteration benötigen (Boilerplate verlangsamt die Entwicklung)
- Sie minimale Abhängigkeiten wünschen
TCA-Kernkonzepte
TCA hat 4 Bausteine — State (Daten), Action (Ereignisse), Reducer (Zustandsentwicklung) und Store (Laufzeit-Engine). Hier sind sie in einer einzigen Funktion:
// STATE — Daten, die Ihre Funktion benötigt
@ObservableState
struct CounterFeature {
var count = 0
var fact: String?
var isLoading = false
}
// ACTION — Alle möglichen Ereignisse
enum Action {
case incrementButtonTapped
case decrementButtonTapped
case factButtonTapped
case factResponse(String)
}
// REDUCER — Wie sich der Zustand als Reaktion auf Aktionen entwickelt
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.fact = fact
state.isLoading = false
return .none
}
}
}
}
// STORE — Verbindet alles
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("Fakt") { store.send(.factButtonTapped) }
.disabled(store.isLoading)
if let fact = store.fact {
Text(fact)
}
}
}
}
TCA im Vergleich zu nativen Mustern
| Aspekt | Native Muster (iOS 26+) | TCA |
|---|---|---|
| Boilerplate | Minimal | Erheblich (Reducer, Actions, Store) |
| Testbarkeit | Gut (Modelle unabhängig testen) | Hervorragend (TestStore, deterministisch) |
| Lernkurve | Niedrig (vertraute Swift-Muster) | Hoch (Redux-Muster, Effekte) |
| Teamkonsistenz | Variabel (Interpretationsspielraum) | Hoch (strenge Muster) |
| Nebenwirkungen | Task/async/await | Effect-Runner, testbar |
| Abhängigkeiten | Keine (nur SwiftUI) | Point-Free-Bibliotheken |
| Beste für | Kleine bis mittlere Apps | Komplexe Apps, große Teams |
Teil 4: Coordinator-Muster
Wann ein Coordinator verwendet werden sollte
Verwenden Sie Coordinator, wenn:
✅ Komplexe Navigationsabläufe — Tiefe Verschachtelung, bedingte Pfade ✅ Deep Linking — Verarbeitung externer URLs/Benachrichtigungen zu korrekten Bildschirmen ✅ Mehrere Einstiegspunkte — Widgets, Shortcuts, Spotlight ✅ Navigation testen — Navigation von View-Logik trennen
❌ Coordinator vermeiden, wenn:
- Einfache Push/Pop-Navigation (< 5 Bildschirme)
- Sie native NavigationStack-Deep-Links verwenden (ausreichend)
- Sie die zusätzliche Indirektionsebene nicht benötigen
Coordinator-Implementierung
// NavigationPath + Coordinator
@Observable
class AppCoordinator {
var path = NavigationPath()
func showSettings() {
path.append(AppRoute.settings)
}
func showDonutDetail(_ donut: Donut) {
path.append(AppRoute.donutDetail(donut))
}
func handleDeepLink(_ url: URL) {
// Deep-Link-Logik zentralisiert
guard let route = DeepLinkParser.parse(url) else { return }
path.append(route)
}
func goBack() {
path.removeLast()
}
}
enum AppRoute: Hashable {
case settings
case donutDetail(Donut)
case orderHistory
}
struct AppView: View {
@State private var coordinator = AppCoordinator()
var body: some View {
NavigationStack(path: $coordinator.path) {
HomeView()
.navigationDestination(for: AppRoute.self) { route in
switch route {
case .settings:
SettingsView()
case .donutDetail(let donut):
DonutDetailView(donut: donut)
case .orderHistory:
OrderHistoryView()
}
}
}
.environment(coordinator)
}
}
Coordinator mit MVVM oder nativen Mustern
// Coordinator + ViewModel
@Observable
class DonutListViewModel {
private let coordinator: AppCoordinator
let donutStore: DonutStore
var donuts: [Donut] { donutStore.all }
init(coordinator: AppCoordinator, donutStore: DonutStore) {
self.coordinator = coordinator
self.donutStore = donutStore
}
func selectDonut(_ donut: Donut) {
coordinator.showDonutDetail(donut)
}
}
struct DonutListView: View {
@Bindable var viewModel: DonutListViewModel
var body: some View {
List(viewModel.donuts) { donut in
Button(donut.name) {
viewModel.selectDonut(donut)
}
}
}
}
Allgemeine Anti-Patterns
❌ Anti-Pattern 1: Logik in View-Bodies
// ❌ Keine Logik in View-Bodies
struct DonutDetailView: View {
let donut: Donut
var body: some View {
let discount = donut.price * 0.10 // ❌ Logik im Body
Text("Ermäßigt: \(discount)")
}
}
// ✅ Logik in berechnete Eigenschaften oder das Modell extrahieren
struct DonutDetailView: View {
let donut: Donut
var discount: Double {
donut.price * 0.10 // ✅ Berechnete Eigenschaft
}
var body: some View {
Text("Ermäßigt: \(discount)")
}
}
❌ Anti-Pattern 2: Übermäßige Extraktion
// ❌ Kein ViewModel für einen einfachen View benötigt
@Observable class WelcomeViewModel {
let userName: String
}
// ✅ Nur das Modell direkt verwenden
struct WelcomeView: View {
let user: User
var body: some View { Text("Willkommen, \(user.name)") }
}
❌ Anti-Pattern 3: @State für von der übergeordneten View besessene Modelle
// ❌ @State erzeugt einen neuen Speicher; die übergeordnete View verliert die Kontrolle
struct ChildView: View {
@State var model: MyModel // ❌ Erzeugt eine Kopie
}
// ✅ @Bindable verwenden, um den Speicher der übergeordneten View zu teilen
struct ChildView: View {
@Bindable var model: MyModel // ✅ Teilt denselben Speicher
}
❌ Anti-Pattern 4: Asynchrone Logik in View-Structs
// ❌ Asynchrone Logik gehört nicht in View-Structs
struct DonutListView: View {
@State private var donuts: [Donut] = []
var body: some View {
List(donuts) { ... }
.task {
donuts = await api.fetchDonuts() // ❌ Netzwerkaufruf im View
}
}
}
// ✅ In ein @Observable-Modell extrahieren
@Observable
class DonutStore {
var donuts: [Donut] = []
func load() async {
donuts = await api.fetchDonuts() // ✅ Im Modell
}
}
struct DonutListView: View {
let store: DonutStore
var body: some View {
List(store.donuts) { ... }
.task { await store.load() }
}
}
Reale Entscheidungsszenarien
Szenario 1: Sie haben einen vorhandenen MVVM-Code und möchten zu nativen Mustern wechseln
- Entfernen Sie ObservableObject -> wechseln Sie zu @Observable
- Entfernen Sie @StateObject in Views -> wechseln Sie zu let/@Bindable
- Verschieben Sie Formatierungslogik in berechnete Eigenschaften
- Verschieben Sie Geschäftslogik zurück in das Modell
- ViewModel als Präsentationsadapter beibehalten, falls noch benötigt
Szenario 2: Neue App, kleines Team, Start-up
Start: Apple Native Muster (Teil 1)
- Minimale Einrichtungszeit
- Keine Drittanbieter-Abhängigkeiten
- Einfach umzustrukturieren, wenn die App wächst
- Fügen Sie Coordinator hinzu, wenn die Navigation komplex wird
Szenario 3: Große App, 10+ Entwickler, strenge Testanforderungen
Erwägen Sie: TCA (Teil 3)
- Strenge Muster halten das Team konsistent
- Hervorragende Testwerkzeuge
- Lernkurve im Voraus in Kauf nehmen für langfristige Wartbarkeit
Szenario 4: App mit tiefen Navigationsabläufen, Deep Linking
Fügen Sie hinzu: Coordinator-Muster (Teil 4)
- Kombinieren Sie mit Ihrem bevorzugten Architekturmuster
- Zentralisieren Sie Deep-Link-Verarbeitung
- NavigationPath + Coordinator Objekt
Zusammenfassung: Wählen Sie Ihren Ansatz
- Standardmäßig: Apple Native Muster (@Observable + State-as-Bridge)
- Wenn Sie mit MVVM vertraut sind: Strukturierte ViewModels als Adapter hinzufügen
- Wenn die App komplex wird: Erwägen Sie TCA für strenge Muster
- Wenn die Navigation komplex wird: Coordinator-Muster hinzufügen
Denken Sie daran: Der beste Ansatz ist der, den Ihr Team konsistent anwenden kann. Perfekte Muster nützen nichts, wenn niemand sie befolgt. Fangen Sie einfach an, entwickeln Sie weiter und extrahieren Sie nach Bedarf.