SwiftUI-Leistungsoptimierung
Wann Sie diese Fertigkeit nutzen sollten
Verwenden, wenn:
- Die App sich weniger reaktionsschnell anfühlt (Ruckler, Hänger, verzögertes Scrollen)
- Animationen während der Ausführung pausieren oder springen
- Die Scroll-Leistung schlecht ist
- Das Profiling zeigt, dass SwiftUI der Flaschenhals ist
- View-Bodies zu lange für die Ausführung benötigen
- Views häufiger aktualisiert werden als nötig
- Sie die Ursache-Wirkung von SwiftUI-Updates verstehen müssen
Beispiel-Prompts
Dies sind reale Fragen von Entwicklern, die diese Fertigkeit zu beantworten entwickelt wurde:
1. "Meine App hat ruckelndes Scrollen und stotternde Animationen. Wie finde ich heraus, ob SwiftUI die Ursache ist?"
→ Die Fertigkeit zeigt, wie man das neue SwiftUI-Instrument in Instruments 26 verwendet, um zu identifizieren, ob SwiftUI im Vergleich zu anderen Ebenen der Flaschenhals ist.
2. "Ich verwende das neue SwiftUI-Instrument und sehe orange/rote Balken, die lange Aktualisierungen anzeigen. Woher weiß ich, was sie verursacht?"
→ Die Fertigkeit behandelt die Ursache-Wirkungs-Graphen-Muster, die den Datenfluss durch Ihre App zeigen und welche Zustandsänderungen teure Aktualisierungen auslösen.
3. "Einige Views aktualisieren sich viel zu oft, obwohl sich ihre Daten nicht geändert haben. Wie finde ich heraus, welche Views das Problem sind?"
→ Die Fertigkeit demonstriert die Erkennung unnötiger Aktualisierungen und die Fehlerbehebung bei der Identität mit der visuellen Zeitleiste.
4. "Ich habe große Datenstrukturen und komplexe View-Hierarchien. Wie optimiere ich sie für die SwiftUI-Leistung?"
→ Die Fertigkeit behandelt Leistungsmuster: Aufbrechen von View-Hierarchien, Minimieren der Body-Komplexität und Verwenden der Optimierungs-Checkliste mit @Sendable.
5. "Wir haben eine Leistungsdeadline und ich muss verstehen, was in SwiftUI langsam ist. Was sind die kritischen Metriken?"
→ Die Fertigkeit bietet den Entscheidungsbaum zur Priorisierung von Optimierungen und versteht Druckszenarien mit professioneller Anleitung für Abwägungen.
Überblick
Kernprinzip: Stellen Sie sicher, dass sich Ihre View-Bodies schnell und nur bei Bedarf aktualisieren, um eine großartige SwiftUI-Leistung zu erzielen.
NEU in WWDC 2025: Das SwiftUI-Instrument der nächsten Generation in Instruments 26 bietet umfassende Leistungsanalyse mit:
- Visueller Zeitleiste langer Aktualisierungen (je nach Schweregrad farblich orange/rot kodiert)
- Ursache-Wirkungs-Graph, der den Datenfluss durch Ihre App zeigt
- Integration mit dem Zeitprofilierer für CPU-Analyse
- Verfolgung von Hängern und Rucklern
Wichtigste Leistungsprobleme:
- Lange View-Body-Updates — View-Bodies benötigen zu viel Zeit für die Ausführung
- Unnötige View-Updates — Views aktualisieren sich, obwohl sich die Daten nicht geändert haben
Leistungsverbesserungen im iOS 26 Framework
"Leistungsverbesserungen am Framework kommen Apps auf allen Apple-Plattformen zugute, von unserer App bis zu Ihrer." — WWDC 2025-256
SwiftUI in iOS 26 enthält große Leistungsgewinne, die allen Apps automatisch zugutekommen. Diese Verbesserungen arbeiten zusammen mit den neuen Profiling-Werkzeugen, um SwiftUI sofort schneller zu machen.
Listenleistung (macOS-Fokus)
Massive Gewinne für große Listen
- 6x schnelleres Laden für Listen mit 100.000+ Einträgen unter macOS
- 16x schnellere Aktualisierungen für große Listen
- Noch größere Gewinne für noch größere Listen
- Verbesserungen kommen allen Plattformen zugute (iOS, iPadOS, watchOS, nicht nur macOS)
List(trips) { trip in // 100k+ Einträge
TripRow(trip: trip)
}
// iOS 26: Lädt 6x schneller, aktualisiert 16x schneller unter macOS
// Alle Plattformen profitieren von den Leistungsverbesserungen
Auswirkungen auf Ihre App
- Große Datensätze (10k+ Einträge) zeigen spürbare Verbesserungen
- Filter- und Sortiervorgänge werden schneller abgeschlossen
- Echtzeitaktualisierungen von Listen reagieren schneller
- Vorteile für Apps wie Dateibrowser, Kontaktlisten, Datentabellen
Scroll-Leistung
Reduzierte verlorene Frames bei Hochgeschwindigkeits-Scrollen
SwiftUI hat die Planung von Benutzeroberflächenaktualisierungen unter iOS und macOS verbessert. Dies verbessert die Reaktionsfähigkeit und gibt SwiftUI mehr Zeit, um sich auf bevorstehende Frames vorzubereiten. Insgesamt verringert es die Wahrscheinlichkeit, dass Ihre App einen Frame fallen lässt, während Sie schnell mit hohen Bildwiederholraten scrollen.
Wichtigste Verbesserungen
- Bessere Frame-Planung — SwiftUI erhält mehr Zeit, um sich auf bevorstehende Frames vorzubereiten
- Verbesserte Reaktionsfähigkeit — UI-Updates werden effizienter geplant
- Weniger verlorene Frames — Besonders beim schnellen Scrollen mit 120 Hz (ProMotion)
Wann Sie es bemerken werden
- Scrollen durch bildlastige Inhalte
- Geräte mit hohen Bildwiederholraten (iPhone Pro, iPad Pro mit ProMotion)
- Komplexe Listenzeilen mit mehreren Views
Verschachtelte ScrollViews mit Lazy Stacks
Fotokarussells und Achsen-Scrollen werden jetzt richtig optimiert
ScrollView(.horizontal) {
LazyHStack {
ForEach(photoSets) { photoSet in
ScrollView(.vertical) {
LazyVStack {
ForEach(photoSet.photos) { photo in
PhotoView(photo: photo)
}
}
}
}
}
}
// iOS 26: Verschachtelte ScrollViews verzögern jetzt das Laden mit Lazy Stacks richtig
// Ideal für Fotokarussells, Netflix-ähnliche Layouts, mehrdimensionale Inhalte
Vor iOS 26 Verschachtelte ScrollViews verzögerten das Laden von Lazy Stack-Inhalten nicht richtig, sodass alle verschachtelten Inhalte sofort geladen wurden.
Nach iOS 26 Lazy Stacks in verschachtelten ScrollViews verzögern jetzt das Laden, bis der Inhalt kurz vor dem Erscheinen ist, was dem Verhalten von einstufigen ScrollViews entspricht.
Anwendungsfälle
- Fotogalerien mit horizontalem/vertikalem Scrollen
- Netflix-ähnliche Kategorienzeilen
- Mehrdimensionale Datenbrowser
- Bilderkarussells mit vertikalem Detail-Scrollen
Erweiterungen des SwiftUI-Leistungsinstruments
Neue Spuren in Instruments 26
Das SwiftUI-Instrument enthält jetzt dedizierte Spuren für:
- Lange View-Body-Updates — Identifizieren teurer Body-Berechnungen
- Plattform-View-Updates — Verfolgen der UIKit/AppKit-Bridging-Leistung (Lange Representable-Updates)
- Andere lange Updates — Alle anderen Arten langer SwiftUI-Arbeit
Diese Spuren werden im nächsten Abschnitt ausführlich behandelt.
Zusammenfassung der Leistungsverbesserungen
Automatische Gewinne (nur Neukompilierung)
- ✅ 6x schnelleres Laden von Listen (100k+ Einträge, macOS)
- ✅ 16x schnellere Listenaktualisierungen (macOS)
- ✅ Reduzierte verlorene Frames beim Scrollen
- ✅ Verbesserte Frame-Planung unter iOS/macOS
- ✅ Optimierung des verzögerten Ladens bei verschachtelten ScrollViews
Keine Code-Änderungen erforderlich — Bauen Sie mit dem iOS 26 SDK neu, um diese Verbesserungen zu erhalten.
Querverweis SwiftUI 26 Funktionen (swiftui-26-ref skill) — Umfassender Leitfaden zu allen iOS 26 SwiftUI-Änderungen
Das SwiftUI-Instrument (Instruments 26)
Erste Schritte
Voraussetzungen:
- Xcode 26 installieren
- Geräte auf die neuesten OS-Versionen aktualisieren (Unterstützung für die Aufzeichnung von SwiftUI-Traces)
- App im Release-Modus für genaues Profiling erstellen
Starten:
- Projekt in Xcode öffnen
- Befehl-I drücken, um zu profilieren
- SwiftUI-Vorlage aus der Vorlagenauswahl wählen
- Auf Aufnahmetaste klicken
Vorlageninhalt
Die SwiftUI-Vorlage enthält drei Instrumente:
- SwiftUI-Instrument (NEU) — Identifiziert Leistungsprobleme im SwiftUI-Code
- Zeitprofilierer — Zeigt CPU-Arbeitsproben im Zeitverlauf
- Hänger und Ruckler — Verfolgt die App-Reaktionsfähigkeit
Spuren des SwiftUI-Instruments
Spur 1: Aktualisierungsgruppen
- Zeigt, wann SwiftUI aktiv arbeitet
- Leer bei CPU-Spitzen? → Problem liegt wahrscheinlich außerhalb von SwiftUI
Spur 2: Lange View-Body-Updates
- Hebt hervor, wenn die
body-Eigenschaft zu lange braucht - Häufigstes Leistungsproblem — hier beginnen
Spur 3: Lange Representable-Updates
- Identifiziert langsame UIViewRepresentable/NSViewRepresentable-Updates
- Leistung der UIKit/AppKit-Integration
Spur 4: Andere lange Updates
- Alle anderen Arten langer SwiftUI-Arbeit
Farbkodierungssystem
Aktualisierungen werden je nach Wahrscheinlichkeit, Ruckler zu verursachen, in orange und rot angezeigt:
- Rot — Sehr wahrscheinlich, zu einem Ruckler/Hänger beizutragen (zuerst untersuchen)
- Orange — Mäßig wahrscheinlich, Probleme zu verursachen
- Grau — Normale Aktualisierungen, nicht besorgniserregend
Hinweis: Ob Aktualisierungen tatsächlich zu Rucklern führen, hängt von den Gerätebedingungen ab, aber rote Aktualisierungen haben die höchste Priorität.
Den Render-Zyklus verstehen
Normales Frame-Rendering
Frame 1:
├─ Ereignisse behandeln (Berührungen, Tastendrücke)
├─ UI aktualisieren (View-Bodies ausführen)
│ └─ Vor der Frame-Frist abschließen ✅
├─ An das System übergeben
└─ System rendert → Auf dem Bildschirm sichtbar
Frame 2:
├─ Ereignisse behandeln
├─ UI aktualisieren
│ └─ Vor der Frame-Frist abschließen ✅
├─ An das System übergeben
└─ System rendert → Auf dem Bildschirm sichtbar
Ergebnis: Sanfte, flüssige Animationen
Frame mit Ruckler (Langer View-Body)
Frame 1:
├─ Ereignisse behandeln
├─ UI aktualisieren
│ └─ EIN VIEW-BODY IST ZU LANGSAM
│ └─ Läuft über die Frame-Frist hinaus ❌
├─ Frist verpasst
└─ Vorheriger Frame bleibt sichtbar (RUCKELER)
Frame 2: (Verzögert)
├─ Ereignisse behandeln (um 1 Frame verzögert)
├─ UI aktualisieren
├─ An das System übergeben
└─ System rendert → Endlich sichtbar
Ergebnis: Vorheriger Frame für 2+ Frames sichtbar = Animationsstottern
Frame mit Ruckler (Zu viele Aktualisierungen)
Frame 1:
├─ Ereignisse behandeln
├─ UI aktualisieren
│ ├─ Update 1 (schnell)
│ ├─ Update 2 (schnell)
│ ├─ Update 3 (schnell)
│ ├─ ... (100 weitere schnelle Updates)
│ └─ Gesamtzeit überschreitet Frist ❌
├─ Frist verpasst
└─ Vorheriger Frame bleibt sichtbar (RUCKELER)
Ergebnis: Viele kleine Updates summieren sich und verpassen die Frist
Wichtige Erkenntnis: Die Laufzeit des View-Bodies ist wichtig, da das Verpassen von Frame-Fristen Ruckler verursacht und Animationen weniger flüssig macht.
Referenz:
- Ruckler in Ihrer App verstehen
- Tech Talk über den Render-Zyklus und die Behebung von Rucklern
Problem 1: Lange View-Body-Updates
Lange Aktualisierungen identifizieren
- Trace aufzeichnen in Instruments mit der SwiftUI-Vorlage
- Auf Spur "Lange View-Body-Updates" achten — irgendwelche orangen/roten Balken?
- SwiftUI-Spur erweitern, um Unterspuren zu sehen
- Unterspur "View-Body-Updates" auswählen
- Auf lange Aktualisierungen filtern:
- Detailbereich → Dropdown → "Zusammenfassung langer View-Body-Updates" wählen
Mit dem Zeitprofilierer analysieren
Workflow:
- Lange Aktualisierung in der Zusammenfassung langer View-Body-Updates finden
- Über den View-Namen schweben → Pfeil klicken → "Updates anzeigen"
- Rechtsklick auf lange Aktualisierung → "Inspektionsbereich festlegen und zoomen"
- Zur Spur des Zeitprofilierers wechseln
Was Sie sehen:
- Aufrufstapel für Proben, die während der Ausführung des View-Bodies aufgezeichnet wurden
- Zeit, die in jedem Frame verbracht wurde (linke Spalte)
- Ihr View-Body, verschachtelt im tiefen SwiftUI-Aufrufstapel
Den Flaschenhals finden:
- Optionsklick, um den Aufrufstapel des Hauptthreads zu erweitern
- Befehl-F zum Suchen nach Ihrem View-Namen (z. B. "LandmarkListItemView")
- Teure Operationen in der Zeitspalte identifizieren
Häufige teure Operationen
Formatierer-Erstellung (Sehr teuer)
❌ FALSCH - Formatierer im View-Body erstellen:
struct LandmarkListItemView: View {
let landmark: Landmark
@State private var userLocation: CLLocation
var distance: String {
// ❌ Erstellt Formatierer jedes Mal, wenn body läuft
let numberFormatter = NumberFormatter()
numberFormatter.maximumFractionDigits = 1
let measurementFormatter = MeasurementFormatter()
measurementFormatter.numberFormatter = numberFormatter
let meters = userLocation.distance(from: landmark.location)
let measurement = Measurement(value: meters, unit: UnitLength.meters)
return measurementFormatter.string(from: measurement)
}
var body: some View {
HStack {
Text(landmark.name)
Text(distance) // Ruft teure distance-Eigenschaft auf
}
}
}
Warum es langsam ist:
- Formatierer sind teuer zu erstellen (Millisekunden pro Stück)
- Werden jedes Mal erstellt, wenn der View-Body läuft
- Läuft auf dem Hauptthread → App wartet, bevor UI-Updates fortgesetzt werden
- Mehrere Views → Zeit summiert sich schnell auf
✅ RICHTIG - Formatierer zentral cachen:
@Observable
class LocationFinder {
private let formatter: MeasurementFormatter
private let landmarks: [Landmark]
private var distanceCache: [Landmark.ID: String] = [:]
init(landmarks: [Landmark]) {
self.landmarks = landmarks
// Formatierer EINMAL während der Initialisierung erstellen
let numberFormatter = NumberFormatter()
numberFormatter.maximumFractionDigits = 1
self.formatter = MeasurementFormatter()
self.formatter.numberFormatter = numberFormatter
updateDistances()
}
func didUpdateLocations(_ locations: [CLLocation]) {
guard let location = locations.last else { return }
updateDistances(from: location)
}
private func updateDistances(from location: CLLocation? = nil) {
guard let location else { return }
for landmark in landmarks {
let meters = location.distance(from: landmark.location)
let measurement = Measurement(value: meters, unit: UnitLength.meters)
distanceCache[landmark.id] = formatter.string(from: measurement)
}
}
func distanceString(for landmarkID: Landmark.ID) -> String {
distanceCache[landmarkID] ?? "Unbekannt"
}
}
struct LandmarkListItemView: View {
let landmark: Landmark
@Environment(LocationFinder.self) private var locationFinder
var body: some View {
HStack {
Text(landmark.name)
Text(locationFinder.distanceString(for: landmark.id)) // ✅ Schneller Lookup
}
}
}
Vorteile:
- Formatierer werden einmal erstellt, für alle Landmarken wiederverwendet
- Zeichenfolgen werden bei Standortänderung vorberechnet
- View-Body liest nur den zwischengespeicherten Wert (sofort)
- Lange View-Body-Updates werden eliminiert
Andere teure Operationen
Komplexe Berechnungen:
// ❌ Nicht im View-Body berechnen
var body: some View {
let result = expensiveAlgorithm(data) // Komplexe Mathematik, Sortierung usw.
Text("\(result)")
}
// ✅ Im Modell berechnen, Ergebnis cachen
@Observable
class ViewModel {
private(set) var result: Int = 0
func updateData(_ data: [Int]) {
result = expensiveAlgorithm(data) // Einmal berechnen
}
}
Netzwerk-/Datei-I/O:
// ❌ NIEMALS I/O im View-Body durchführen
var body: some View {
let data = try? Data(contentsOf: fileURL) // ❌ Synchroner I/O
// ...
}
// ✅ Asynchron laden
…
[gekürzt für die Übersetzung]