@ObservedObject: mi ez, hogyan működik és példák

Mi az @ObservedObject a SwiftUI-ban?

@ObservedObject egy Property Wrapper, amely feliratkoztatja a nézetet az ObservableObject változásaira. Az ObservableObject egy protokoll a Combine keretrendszerből, amely megköveteli az objectWillChange publisher megvalósítását. Amikor bármely @Published-tel jelölt tulajdonság megváltozik az ObservableObject-en belül, a publisher jelet küld, és a SwiftUI újrarajzolja az összes @ObservedObject-en keresztül feliratkozott nézetet.

Az @ObservedObject fő jellemzője a tulajdonlás hiánya. A nézet nem felelős az objektum létrehozásáért vagy megsemmisítéséért. Az objektum a szülő nézetben (@StateObject-en keresztül) jön létre, vagy @EnvironmentObject-en keresztül kerül beinjektálásra. A gyermek nézet csak megfigyeli a változásokat és frissítéseket kap. Ha az objektumot a szülőben kicserélik, az @ObservedObject átvált az új példányra.

Az @ObservedObject alkalmas adatmegosztási forgatókönyvekhez: felhasználói modell, közös beállítások, szerverkapcsolat állapota. Amikor több nézet a hierarchia különböző szintjein ugyanazokat az adatokat kell megjelenítse, az @ObservedObject minden nézetben független, de összehangolt feliratkozásokat hoz létre egy forrásra.

@ObservedObject vs @StateObject: fő különbségek

A @ObservedObject és a @StateObject közötti különbség az egyik leggyakoribb kérdés a SwiftUI interjúkon. Az alapszabály: a @StateObject létrehozza és birtokolja az objektumot, az @ObservedObject egy meglévőt figyel meg. A szabály megsértése váratlan adatvesztéshez vagy dupla inicializációhoz vezet.

@StateObject garantálja, hogy az objektum egyszer jön létre és túléli a nézetstruktúra ismételt inicializálásait. Az @ObservedObject kívülről kapja az objektumot, és minden szülőstruktúra-inicializáláskor újra létrejön. Ha a szülő @StateObject-et használ az objektumhoz, a gyermek nézetek biztonságosan alkalmazhatják az @ObservedObject-et — az objektum egyedi lesz a teljes hierarchiában.

Hogyan követi nyomon az @ObservedObject a változásokat

Az @ObservedObject nyomonkövetési mechanizmusa a Combine-on és az ObservableObject protokollon alapul. Inicializáláskor a SwiftUI meghívja az objectWillChange publishtert — az objektumnak jelet kell küldenie a @Published tulajdonság megváltozása előtt. A Combine továbbítja a jelet a SwiftUI függőségi gráfjába, amely az összes függő nézetet frissítendőként jelöli meg. Ez szinkron módon történik az érték megváltozása előtt.

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")
        }
    }
}

A listában a WeatherService egy ObservableObject két @Published tulajdonsággal. A WeatherView deklarálja az @ObservedObject var weather: WeatherService-t, a példányt a szülőtől kapva. Amikor a temperature megváltozik, az objectWillChange az új érték beállítása előtt aktiválódik, a SwiftUI újrarajzolja a WeatherView-t, és megjelenik az aktuális hőmérséklet. A feliratkozást a SwiftUI automatikusan kezeli — a fejlesztőnek nem kell sink-et vagy dispose-t hívnia.

Az @ObservedObject használati mintái

Az első minta — a modell átadása inicializátoron keresztül. A szülő létrehozza az ObservableObject-et @StateObject-en keresztül, és @ObservedObject-ként adja át a gyermek nézeteknek. Ez egy szabványos hierarchikus adatátvitel, ahol a gyökér nézet kezeli a modell életciklusát, és az összes beágyazott komponens feliratkozik a változásokra.

A második minta — EnvironmentObject, az @ObservedObject globális verziója a SwiftUI Environment-en keresztül. Az objektum a scene vagy a gyökér nézet szintjén kerül beinjektálásra, és automatikusan elérhető az összes gyermek komponens számára explicit átadás nélkül. A gyermek nézeten belül az @EnvironmentObject az @ObservedObject-hez hasonlóan működik, de az objektumot a környezetből veszi.

A harmadik minta — több ObservableObject kompozíciója. Összetett alkalmazásokban a nézet több objektumot is megfigyelhet: @ObservedObject var user: UserService, @ObservedObject var network: NetworkMonitor. Ez szétválasztja a felelősséget a szolgáltatások között, és megőrzi az egyes komponensek tesztelhetőségét.

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

    var body: some View {
        VStack {
            Text("Üdvözöljük, \\(user.name)")
            HStack {
                Circle()
                    .fill(network.isConnected ? Color.green : Color.red)
                    .frame(width: 10, height: 10)
            }
        }
    }
}

DashboardView megfigyeli a UserViewModel-t és a NetworkMonitor-t. Minden objektum a saját adatterületéért felelős, és függetlenül értesíti a nézetet a változásokról. Ha a hálózat megszakad, a NetworkMonitor megváltoztatja az isConnected-et, és a SwiftUI újrarajzolja a DashboardView-t, frissítve az indikátor színét. Az ObservableObject kompozíció az előnyben részesített adatszervezési mód a SwiftUI alkalmazásokban.

@Published: az ObservableObject és a SwiftUI kapcsolata

@Published egy Property Wrapper a Combine-ból, amely automatikusan hozzáad egy publishtert az ObservableObject-en belüli tulajdonsághoz. Amikor a @Published tulajdonság megváltozik, a Combine eseményt generál az objectWillChange publishteren keresztül. A SwiftUI feliratkozik erre a publisherre, amikor @ObservedObject-et vagy @StateObject-et használ, és minden új értéknél újrarajzolja a nézetet.

@Published támogatja az összes típust, beleértve az opcionálisokat, gyűjteményeket és egyéni struktúrákat. A gyűjtemények (tömbök, szótárak) esetében azonban a SwiftUI csak a referencia cseréjét követi nyomon, nem a tartalom változását. Egy elem hozzáadásának vagy eltávolításának észleléséhez újra kell rendelnie a teljes gyűjteményt, vagy ObservableObject-et kell használnia manuális objectWillChange.send()-del.

Fontos részlet: a @Published csak az ObservableObject-et megvalósító osztályon belül lehet. A @Published használata ObservableObject-en kívül fordítási hibát eredményez. Ezenkívül a @Published nem alkalmazható lusta inicializálású (lazy var) vagy számított tulajdonságokra (computed property).

Gyakori hibák az @ObservedObject-tel

A legkritikusabb hiba — az @ObservedObject használata objektum létrehozására. Ha @ObservedObject var model = UserViewModel()-t ír a szülő nézetben, minden rendereléskor új UserViewModel példány jön létre. Az adatok elvesznek, a @Published feliratkozások újra létrejönnek. Mindig a @StateObject-et használja a létrehozáshoz, és az @ObservedObject-et csak a kész objektum fogadásához.

A második hiba — a @Published tulajdonságok módosítása a fő szálon kívül. Az ObservableObject a Combine-ot használja, amely megköveteli a változtatások küldését a fő szálon (main actor). Ha egy @Published tulajdonságot háttérvárakozási sorban módosít, a SwiftUI alkalmatlan időben rajzolhatja újra a nézetet, versenyhelyzeteket okozva. Használjon DispatchQueue.main.async-ot vagy @MainActor-t a frissítéshez.

A harmadik probléma — ciklikus frissítések. Ha egy @Published változás olyan mellékhatásokat tartalmaz, amelyek ismét megváltoztatják a @Published-et, végtelen újrarajzolási ciklus alakul ki. Megoldás: használjon védőjelzőket (isUpdating), vagy ossza szét a logikát különböző ObservableObject-ekre egyértelmű felelősségi határokkal.