@ObservedObject: Was ist das, wie funktioniert es und Beispiele

Was ist @ObservedObject in SwiftUI?

@ObservedObject ist ein Property Wrapper, der einen View für Änderungen eines ObservableObject abonniert. ObservableObject ist ein Protokoll aus dem Combine-Framework, das die Implementierung eines objectWillChange-Publishers erfordert. Wenn eine mit @Published markierte Eigenschaft innerhalb des ObservedObject geändert wird, sendet der Publisher ein Signal, und SwiftUI zeichnet alle über @ObservedObject abonnierten Views neu.

Das Hauptmerkmal von @ObservedObject ist die fehlende Besitzerschaft. Der View ist nicht für die Erstellung oder Zerstörung des Objekts verantwortlich. Das Objekt wird im übergeordneten View (über @StateObject) erstellt oder über @EnvironmentObject injiziert. Der untergeordnete View beobachtet nur Änderungen und erhält Aktualisierungen. Wenn das Objekt im Elternteil ersetzt wird, wechselt @ObservedObject zur neuen Instanz.

@ObservedObject eignet sich für Datenfreigabeszenarien: Benutzermodell, gemeinsame Einstellungen, Serververbindungsstatus. Wenn mehrere Views auf verschiedenen Hierarchieebenen dieselben Daten anzeigen müssen, erstellt @ObservedObject in jedem View unabhängige, aber konsistente Abonnements für eine einzige Quelle.

@ObservedObject vs @StateObject: Hauptunterschiede

Der Unterschied zwischen @ObservedObject und @StateObject ist eines der häufigsten Themen in SwiftUI-Vorstellungsgesprächen. Die Hauptregel: @StateObject erstellt und besitzt das Objekt, @ObservedObject beobachtet ein bereits existierendes. Ein Verstoß gegen diese Regel führt zu unerwartetem Datenverlust oder doppelter Initialisierung.

@StateObject garantiert, dass das Objekt einmal erstellt wird und wiederholte Initialisierungen der View-Struktur überlebt. @ObservedObject erhält das Objekt von außen und wird bei jeder Initialisierung der Elternstruktur neu erstellt. Wenn der Elternteil @StateObject für das Objekt verwendet, können untergeordnete Views sicher @ObservedObject anwenden – das Objekt ist in der gesamten Hierarchie eindeutig.

Wie @ObservedObject Änderungen verfolgt

Der Verfolgungsmechanismus von @ObservedObject basiert auf Combine und dem ObservableObject-Protokoll. Während der Initialisierung ruft SwiftUI den objectWillChange-Publisher auf – das Objekt muss vor Änderung einer @Published-Eigenschaft ein Signal senden. Combine leitet das Signal an den SwiftUI-Abhängigkeitsgraphen weiter, der alle abhängigen Views als aktualisierungsbedürftig markiert. Dies geschieht synchron vor der Wertänderung.

class WeatherService: ObservableObject {
    @Published var temperature: Double = 22.0
    @Published var city: String = "Moscow"
}

struct WeatherView: View {
    @ObservedObject var weather: WeatherService

    var body: some View {
        VStack {
            Text("\(weather.city)")
            Text("\(weather.temperature)°C")
        }
    }
}

Im Listing ist WeatherService ein ObservableObject mit zwei @Published-Eigenschaften. WeatherView deklariert @ObservedObject var weather: WeatherService und erhält die Instanz vom Elternteil. Wenn sich temperature ändert, wird objectWillChange vor dem Setzen des neuen Werts ausgelöst, SwiftUI zeichnet WeatherView neu und die aktuelle Temperatur wird angezeigt. Das Abonnement wird automatisch von SwiftUI verwaltet – der Entwickler muss weder sink noch dispose aufrufen.

Verwendungsmuster von @ObservedObject

Das erste Muster ist die Übergabe eines Modells über den Initialisierer. Der Elternteil erstellt ein ObservableObject über @StateObject und übergibt es an untergeordnete Views als @ObservedObject. Dies ist eine standardmäßige hierarchische Datenübertragung, bei der der Root-View den Lebenszyklus des Modells verwaltet und alle verschachtelten Komponenten Änderungen abonnieren.

Das zweite Muster ist EnvironmentObject, eine globale Version von @ObservedObject über die SwiftUI-Umgebung. Das Objekt wird auf Szenen- oder Root-View-Ebene injiziert und ist automatisch für alle untergeordneten Komponenten verfügbar, ohne explizite Übergabe über Initialisierer. Innerhalb des untergeordneten Views funktioniert @EnvironmentObject ähnlich wie @ObservedObject, erhält das Objekt jedoch aus der Umgebung.

Das dritte Muster ist die Komposition mehrerer ObservableObject. In komplexen Anwendungen kann ein View mehrere Objekte beobachten: @ObservedObject var user: UserService, @ObservedObject var network: NetworkMonitor. Dies trennt Verantwortlichkeiten zwischen Diensten und bewahrt die Testbarkeit jeder Komponente.

struct DashboardView: View {
    @ObservedObject var user: UserViewModel
    @ObservedObject var network: NetworkMonitor

    var body: some View {
        VStack {
            Text("Welcome, \(user.name)")
            HStack {
                Circle()
                    .fill(network.isConnected ? Color.green : Color.red)
                    .frame(width: 10, height: 10)
            }
        }
    }
}

DashboardView beobachtet UserViewModel und NetworkMonitor. Jedes Objekt verwaltet seine eigene Datendomäne und benachrichtigt den View unabhängig über Änderungen. Wenn die Netzwerkverbindung getrennt wird, ändert NetworkMonitor isConnected, und SwiftUI zeichnet DashboardView neu, wobei die Indikatorfarbe aktualisiert wird. Die Komposition von ObservableObject ist die bevorzugte Methode zur Datenorganisation in SwiftUI-Anwendungen.

@Published: Die Verbindung zwischen ObservableObject und SwiftUI

@Published ist ein Property Wrapper aus Combine, der einer Eigenschaft innerhalb von ObservableObject automatisch einen Publisher hinzufügt. Wenn eine @Published-Eigenschaft geändert wird, generiert Combine ein Ereignis über den objectWillChange-Publisher. SwiftUI abonniert diesen Publisher bei Verwendung von @ObservedObject oder @StateObject und zeichnet den View bei jedem neuen Wert neu.

@Published unterstützt alle Typen, einschließlich Optionale, Sammlungen und benutzerdefinierte Strukturen. Bei Sammlungen (Arrays, Wörterbücher) verfolgt SwiftUI jedoch nur die Referenzersetzung, nicht die Inhaltsänderung. Um das Hinzufügen oder Entfernen von Elementen zu erkennen, müssen Sie die gesamte Sammlung neu zuweisen oder ObservableObject mit manuellem objectWillChange.send() verwenden.

Ein wichtiges Detail: @Published darf nur innerhalb einer Klasse verwendet werden, die ObservableObject implementiert. Die Verwendung von @Published außerhalb von ObservableObject führt zu einem Kompilierungsfehler. Außerdem kann @Published nicht auf Eigenschaften mit verzögerter Initialisierung (lazy var) oder berechnete Eigenschaften angewendet werden.

Häufige Fehler mit @ObservedObject

Der kritischste Fehler ist die Verwendung von @ObservedObject zum Erstellen eines Objekts. Wenn Sie im übergeordneten View @ObservedObject var model = UserViewModel() schreiben, wird bei jedem Rendern eine neue UserViewModel-Instanz erstellt. Daten gehen verloren und @Published-Abonnements werden neu erstellt. Verwenden Sie immer @StateObject zum Erstellen und @ObservedObject nur zum Empfangen eines fertigen Objekts.

Der zweite Fehler ist die Änderung von @Published-Eigenschaften außerhalb des Hauptthreads. ObservableObject verwendet Combine, das das Senden von Änderungen im Hauptthread (main actor) erfordert. Wenn Sie @Published in einer Hintergrundwarteschlange ändern, kann SwiftUI den View zu einem ungeeigneten Zeitpunkt neu zeichnen, was zu Wettlaufsituationen führt. Verwenden Sie DispatchQueue.main.async oder @MainActor für Aktualisierungen.

Das dritte Problem sind zyklische Aktualisierungen. Wenn eine @Published-Änderung Nebeneffekte auslöst, die erneut @Published ändern, entsteht eine Endlosschleife von Neuzeichnungen. Die Lösung: Verwenden Sie Schutzflags (isUpdating) oder trennen Sie die Logik auf verschiedene ObservableObject mit klaren Verantwortungsbereichen.