@ObservedObject: यह क्या है, कैसे काम करता है और उदाहरण

SwiftUI में @ObservedObject क्या है?

@ObservedObject एक Property Wrapper है जो किसी व्यू को ObservableObject के बदलावों की सदस्यता प्रदान कराता है। ObservableObject Combine फ्रेमवर्क का एक प्रोटोकॉल है जिसे objectWillChange publisher को लागू करने की आवश्यकता होती है। जब @Published से चिह्नित कोई भी गुण ObservedObject के अंदर बदलता है, publisher एक सिग्नल भेजता है और SwiftUI @ObservedObject के माध्यम से सब्सक्राइब किए गए सभी व्यू को पुनः रेंडर करता है।

@ObservedObject की मुख्य विशेषता स्वामित्व की कमी है। व्यू ऑब्जेक्ट बनाने या नष्ट करने के लिए ज़िम्मेदार नहीं है। ऑब्जेक्ट पैरेंट व्यू में (@StateObject के माध्यम से) बनाया जाता है या @EnvironmentObject के माध्यम से इंजेक्ट किया जाता है। चाइल्ड व्यू केवल बदलावों को देखता है और अपडेट प्राप्त करता है। यदि पैरेंट में ऑब्जेक्ट बदल दिया जाता है, @ObservedObject नए इंस्टेंस पर स्विच हो जाता है।

@ObservedObject डेटा साझाकरण परिदृश्यों के लिए उपयुक्त है: उपयोगकर्ता मॉडल, सामान्य सेटिंग्स, सर्वर कनेक्शन स्थिति। जब विभिन्न पदानुक्रम स्तरों पर कई व्यू को एक ही डेटा प्रदर्शित करने की आवश्यकता होती है, @ObservedObject प्रत्येक व्यू में एक ही स्रोत के लिए स्वतंत्र लेकिन सुसंगत सदस्यताएँ बनाता है।

@ObservedObject vs @StateObject: मुख्य अंतर

@ObservedObject और @StateObject के बीच अंतर SwiftUI साक्षात्कारों में सबसे सामान्य प्रश्नों में से एक है। मुख्य नियम: @StateObject ऑब्जेक्ट बनाता है और उसका मालिक होता है, @ObservedObject पहले से मौजूद ऑब्जेक्ट को देखता है। इस नियम का उल्लंघन करने से अप्रत्याशित डेटा हानि या दोहरी आरंभीकरण होता है।

@StateObject गारंटी देता है कि ऑब्जेक्ट एक बार बनता है और व्यू संरचना के बार-बार आरंभीकरण से बचता है। @ObservedObject ऑब्जेक्ट को बाहर से प्राप्त करता है और प्रत्येक पैरेंट संरचना आरंभीकरण के साथ पुनः बनता है। यदि पैरेंट ऑब्जेक्ट के लिए @StateObject का उपयोग करता है, चाइल्ड व्यू सुरक्षित रूप से @ObservedObject लागू कर सकते हैं — ऑब्जेक्ट पूरे पदानुक्रम में अद्वितीय होगा।

@ObservedObject बदलावों को कैसे ट्रैक करता है

@ObservedObject की ट्रैकिंग तंत्र Combine और ObservableObject प्रोटोकॉल पर आधारित है। आरंभीकरण के दौरान, SwiftUI objectWillChange publisher को कॉल करता है — ऑब्जेक्ट को @Published गुण बदलने से पहले एक सिग्नल उत्सर्जित करना होता है। Combine सिग्नल को SwiftUI डिपेंडेंसी ग्राफ में भेजता है, जो सभी आश्रित व्यू को अपडेट की आवश्यकता वाले के रूप में चिह्नित करता है। यह मान बदलने से पहले समकालिक रूप से होता है।

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

लिस्टिंग में WeatherService दो @Published गुणों वाला ObservableObject है। WeatherView @ObservedObject var weather: WeatherService घोषित करता है, पैरेंट से इंस्टेंस प्राप्त करता है। जब temperature बदलता है, objectWillChange नया मान सेट करने से पहले फायर होता है, SwiftUI WeatherView को पुनः रेंडर करता है और वास्तविक तापमान प्रदर्शित होता है। सदस्यता स्वचालित रूप से SwiftUI द्वारा प्रबंधित की जाती है — डेवलपर को sink या dispose कॉल करने की आवश्यकता नहीं है।

@ObservedObject उपयोग पैटर्न

पहला पैटर्न आरंभक के माध्यम से मॉडल पास करना है। पैरेंट @StateObject के माध्यम से ObservableObject बनाता है और इसे चाइल्ड व्यू को @ObservedObject के रूप में पास करता है। यह एक मानक पदानुक्रमित डेटा स्थानांतरण है जहाँ रूट व्यू मॉडल के जीवनचक्र का प्रबंधन करता है और सभी नेस्टेड घटक बदलावों की सदस्यता लेते हैं।

दूसरा पैटर्न EnvironmentObject है, जो SwiftUI Environment के माध्यम से @ObservedObject का वैश्विक संस्करण है। ऑब्जेक्ट सीन या रूट व्यू स्तर पर इंजेक्ट किया जाता है और आरंभकों के माध्यम से स्पष्ट पासिंग के बिना सभी चाइल्ड घटकों के लिए स्वचालित रूप से उपलब्ध होता है। चाइल्ड व्यू के अंदर, @EnvironmentObject @ObservedObject के समान काम करता है लेकिन ऑब्जेक्ट को पर्यावरण से प्राप्त करता है।

तीसरा पैटर्न कई ObservableObject की रचना है। जटिल अनुप्रयोगों में, एक व्यू कई ऑब्जेक्ट्स को देख सकता है: @ObservedObject var user: UserService, @ObservedObject var network: NetworkMonitor। यह सेवाओं के बीच ज़िम्मेदारियों को अलग करता है और प्रत्येक घटक की परीक्षण क्षमता बनाए रखता है।

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 और NetworkMonitor को देखता है। प्रत्येक ऑब्जेक्ट अपने डेटा डोमेन को संभालता है और स्वतंत्र रूप से व्यू को बदलावों की सूचना देता है। यदि नेटवर्क डिस्कनेक्ट होता है, NetworkMonitor isConnected बदलता है, और SwiftUI DashboardView को पुनः रेंडर करता है, इंडिकेटर रंग अपडेट करता है। ObservableObject की रचना SwiftUI अनुप्रयोगों में डेटा व्यवस्थित करने का पसंदीदा तरीका है।

@Published: ObservableObject और SwiftUI के बीच संबंध

@Published Combine का एक Property Wrapper है जो ObservableObject के अंदर किसी गुण में स्वचालित रूप से publisher जोड़ता है। जब @Published गुण बदलता है, Combine objectWillChange publisher के माध्यम से एक इवेंट उत्पन्न करता है। @ObservedObject या @StateObject का उपयोग करते समय SwiftUI इस publisher की सदस्यता लेता है और प्रत्येक नए मान पर व्यू को पुनः रेंडर करता है।

@Published सभी प्रकारों का समर्थन करता है, जिसमें वैकल्पिक, संग्रह और कस्टम संरचनाएँ शामिल हैं। हालांकि, संग्रह (सरणियाँ, शब्दकोश) के लिए, SwiftUI केवल संदर्भ प्रतिस्थापन को ट्रैक करता है, सामग्री परिवर्तन को नहीं। तत्व जोड़ या हटाने का पता लगाने के लिए, आपको पूरे संग्रह को पुनः असाइन करना होगा या मैन्युअल objectWillChange.send() के साथ ObservableObject का उपयोग करना होगा।

एक महत्वपूर्ण विवरण: @Published का उपयोग केवल ObservableObject को लागू करने वाले class के अंदर किया जाना चाहिए। ObservableObject के बाहर @Published का उपयोग करने से संकलन त्रुटि होगी। साथ ही, @Published को आलसी आरंभीकरण गुणों (lazy var) या गणना किए गए गुणों पर लागू नहीं किया जा सकता।

@ObservedObject के साथ सामान्य गलतियाँ

सबसे गंभीर गलती किसी ऑब्जेक्ट को बनाने के लिए @ObservedObject का उपयोग करना है। यदि आप पैरेंट व्यू में @ObservedObject var model = UserViewModel() लिखते हैं, प्रत्येक रेंडर एक नया UserViewModel इंस्टेंस बनाएगा। डेटा खो जाएगा और @Published सदस्यताएँ पुनः बनाई जाएँगी। निर्माण के लिए हमेशा @StateObject का और केवल तैयार ऑब्जेक्ट प्राप्त करने के लिए @ObservedObject का उपयोग करें।

दूसरी गलती @Published गुणों को मुख्य थ्रेड से बाहर संशोधित करना है। ObservableObject Combine का उपयोग करता है जिसे मुख्य थ्रेड (main actor) पर बदलाव भेजने की आवश्यकता होती है। यदि आप पृष्ठभूमि कतार में @Published बदलते हैं, SwiftUI अनुपयुक्त समय पर व्यू को पुनः रेंडर कर सकता है, जिससे रेस कंडीशन हो सकती है। अपडेट के लिए DispatchQueue.main.async या @MainActor का उपयोग करें।

तीसरी समस्या चक्रीय अपडेट है। यदि @Published परिवर्तन ऐसे दुष्प्रभाव उत्पन्न करता है जो फिर से @Published बदलते हैं, तो अनंत पुनः रेंडर लूप होता है। समाधान: गार्ड फ़्लैग (isUpdating) का उपयोग करें या स्पष्ट ज़िम्मेदारी सीमाओं के साथ तर्क को विभिन्न ObservableObject में अलग करें।