@ObservedObject: nedir, nasıl çalışır ve örnekler

SwiftUI'de @ObservedObject Nedir?

@ObservedObject, bir görünümü ObservableObject'in değişikliklerine abone yapan bir Property Wrapper'dır. ObservableObject, Combine framework'ünden objectWillChange yayıncısını uygulamayı gerektiren bir protokoldür. @Published ile işaretlenmiş herhangi bir özellik ObservedObject içinde değiştiğinde, yayıncı bir sinyal gönderir ve SwiftUI @ObservedObject aracılığıyla abone olan tüm görünümleri yeniden çizer.

@ObservedObject'in ana özelliği sahipliğin olmamasıdır. Görünüm, nesneyi oluşturmaktan veya yok etmekten sorumlu değildir. Nesne, üst görünümde (@StateObject aracılığıyla) oluşturulur veya @EnvironmentObject aracılığıyla enjekte edilir. Alt görünüm yalnızca değişiklikleri gözlemler ve güncellemeleri alır. Üst öğede nesne değiştirilirse, @ObservedObject yeni örneğe geçer.

@ObservedObject veri paylaşım senaryoları için uygundur: kullanıcı modeli, ortak ayarlar, sunucu bağlantı durumu. Farklı hiyerarşi seviyelerindeki birden çok görünüm aynı verileri görüntülemesi gerektiğinde, her görünümdeki @ObservedObject tek bir kaynak için bağımsız ancak tutarlı abonelikler oluşturur.

@ObservedObject vs @StateObject: Temel Farklar

@ObservedObject ve @StateObject arasındaki fark, SwiftUI mülakatlarında en sık sorulan konulardan biridir. Temel kural: @StateObject nesneyi oluşturur ve sahiplenir, @ObservedObject zaten var olan bir nesneyi gözlemler. Bu kuralı ihlal etmek beklenmedik veri kaybına veya çift başlatmaya yol açar.

@StateObject nesnenin bir kez oluşturulmasını ve görünüm yapısının tekrarlanan başlatmalarından kurtulmasını garanti eder. @ObservedObject nesneyi dışarıdan alır ve her üst yapı başlatmasında yeniden oluşturulur. Üst öğe nesne için @StateObject kullanıyorsa, alt görünümler güvenle @ObservedObject uygulayabilir — nesne tüm hiyerarşide benzersiz olacaktır.

@ObservedObject Değişiklikleri Nasıl İzler?

@ObservedObject'in izleme mekanizması Combine ve ObservableObject protokolüne dayanır. Başlatma sırasında SwiftUI objectWillChange yayıncısını çağırır — nesne, @Published özelliğini değiştirmeden önce bir sinyal yaymalıdır. Combine sinyali SwiftUI bağımlılık grafiğine iletir ve bağımlı tüm görünümleri güncelleme gerekiyor olarak işaretler. Bu, değer değişmeden önce eşzamanlı olarak gerçekleşir.

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

Listede WeatherService iki @Published özelliğine sahip bir ObservableObject'tir. WeatherView, @ObservedObject var weather: WeatherService bildirir ve örneği üst öğeden alır. temperature değiştiğinde, yeni değer ayarlanmadan önce objectWillChange tetiklenir, SwiftUI WeatherView'i yeniden çizer ve gerçek sıcaklık görüntülenir. Abonelik SwiftUI tarafından otomatik olarak yönetilir — geliştiricinin sink veya dispose çağırması gerekmez.

@ObservedObject Kullanım Desenleri

İlk desen, modeli başlatıcı aracılığıyla aktarmaktır. Üst öğe @StateObject aracılığıyla bir ObservableObject oluşturur ve alt görünümlere @ObservedObject olarak aktarır. Bu, kök görünümün modelin yaşam döngüsünü yönettiği ve tüm iç içe bileşenlerin değişikliklere abone olduğu standart bir hiyerarşik veri aktarımıdır.

İkinci desen EnvironmentObject'tir, SwiftUI Ortamı aracılığıyla @ObservedObject'in küresel bir sürümüdür. Nesne, sahne veya kök görünüm düzeyinde enjekte edilir ve başlatıcılar aracılığıyla açık aktarım olmadan tüm alt bileşenler için otomatik olarak kullanılabilir. Alt görünüm içinde @EnvironmentObject, @ObservedObject'e benzer şekilde çalışır ancak nesneyi ortamdan alır.

Üçüncü desen, birden çok ObservableObject'in kompozisyonudur. Karmaşık uygulamalarda, bir görünüm birden çok nesneyi gözlemleyebilir: @ObservedObject var user: UserService, @ObservedObject var network: NetworkMonitor. Bu, hizmetler arasında sorumlulukları ayırır ve her bileşenin test edilebilirliğini korur.

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 UserViewModel ve NetworkMonitor'u gözlemler. Her nesne kendi veri alanını yönetir ve bağımsız olarak görünüme değişiklikleri bildirir. Ağ bağlantısı kesilirse, NetworkMonitor isConnected'i değiştirir ve SwiftUI DashboardView'i yeniden çizerek gösterge rengini günceller. ObservableObject kompozisyonu, SwiftUI uygulamalarında veri düzenlemenin tercih edilen yoludur.

@Published: ObservableObject ve SwiftUI Arasındaki Bağlantı

@Published, ObservableObject içindeki bir özelliğe otomatik olarak bir yayıncı ekleyen Combine'dan bir Property Wrapper'dır. @Published özelliği değiştiğinde, Combine objectWillChange yayıncısı aracılığıyla bir olay oluşturur. @ObservedObject veya @StateObject kullanırken SwiftUI bu yayıncıya abone olur ve her yeni değerde görünümü yeniden çizer.

@Published, isteğe bağlılar, koleksiyonlar ve özel yapılar dahil tüm türleri destekler. Ancak, koleksiyonlar (diziler, sözlükler) için SwiftUI yalnızca referans değiştirmeyi izler, içerik değişikliğini izlemez. Öğe ekleme veya kaldırmayı tespit etmek için tüm koleksiyonu yeniden atamanız veya manuel objectWillChange.send() ile ObservableObject kullanmanız gerekir.

Önemli bir detay: @Published yalnızca ObservableObject'i uygulayan bir class içinde kullanılmalıdır. ObservableObject dışında @Published kullanmak derleme hatasına neden olur. Ayrıca @Published, tembel başlatma özelliklerine (lazy var) veya hesaplanmış özelliklere uygulanamaz.

@ObservedObject ile Sık Yapılan Hatalar

En kritik hata, bir nesne oluşturmak için @ObservedObject kullanmaktır. Üst görünümde @ObservedObject var model = UserViewModel() yazarsanız, her render yeni bir UserViewModel örneği oluşturur. Veri kaybolur ve @Published abonelikleri yeniden oluşturulur. Oluşturma için her zaman @StateObject'i ve yalnızca hazır bir nesne almak için @ObservedObject'i kullanın.

İkinci hata, @Published özelliklerini ana iş parçacığı dışında değiştirmektir. ObservableObject, değişikliklerin ana iş parçacığında (main actor) gönderilmesini gerektiren Combine'ı kullanır. @Published'i bir arka plan kuyruğunda değiştirirseniz, SwiftUI görünümü uygun olmayan bir zamanda yeniden çizerek yarış koşullarına neden olabilir. Güncellemeler için DispatchQueue.main.async veya @MainActor kullanın.

Üçüncü sorun döngüsel güncellemelerdir. Bir @Published değişikliği, tekrar @Published'i değiştiren yan etkileri tetiklerse, sonsuz bir yeniden çizim döngüsü oluşur. Çözüm: koruma bayrakları (isUpdating) kullanmak veya mantığı net sorumluluk sınırları olan farklı ObservableObject'lere ayırmaktır.