.task { } — यह क्या है, async मॉडिफ़ायर और View में डेटा लोडिंग

SwiftUI में .task { } क्या है

.task { } एक View मॉडिफ़ायर है जो View के स्क्रीन पर प्रकट होने पर async कॉन्टेक्स्ट में Task बनाता है। SwiftUI प्रदान किए गए क्लोज़र को बैकग्राउंड थ्रेड पर निष्पादित करता है, मुख्य थ्रेड को UI ऑपरेशन के लिए मुक्त रखता है। जब View गायब होता है, SwiftUI Structured Concurrency तंत्र के माध्यम से स्वचालित रूप से Task को रद्द कर देता है — यह सुनिश्चित करता है कि एसिंक्रोनस ऑपरेशन तब भी निष्पादित न हो जब उसका परिणाम आवश्यक न रह जाए।

Apple — Swift Programming Language (2025) के अनुसार, .task Swift 5.5 में प्रस्तुत Structured Concurrency की अवधारणा का उपयोग करता है। प्रत्येक .task पैरेंट View के कार्य के अंतर्गत एक चाइल्ड कार्य बनाता है। यदि पैरेंट कार्य रद्द हो जाता है (View गायब होता है), तो सभी चाइल्ड कार्य भी स्वचालित रूप से रद्द हो जाते हैं। यह DispatchWorkItem या AnyCancellable के संदर्भों को मैन्युअल रूप से संग्रहीत करने की तुलना में एसिंक्रोनस ऑपरेशन के जीवनचक्र प्रबंधन को मौलिक रूप से सरल बनाता है।

@State + .onAppear में मैन्युअल कॉल के पारंपरिक दृष्टिकोण के विपरीत, .task को बाद में रद्दीकरण के लिए Task का संदर्भ संग्रहीत करने की आवश्यकता नहीं होती। SwiftUI इसे स्वचालित रूप से करता है, बॉयलरप्लेट कोड को कम करता है और कार्य को रद्द करना भूल जाने के जोखिम को समाप्त करता है।

struct ArticlesView: View {
    @State var articles: [Article] = []
    @State var error: Error?
    
    var body: some View {
        List(articles) { article in
            Text(article.title)
        }
        .task {
            do {
                articles = await APIClient().fetchArticles()
            } catch {
                self.error = error
            }
        }
    }
}

.task बनाम .onAppear: मुख्य अंतर

कई डेवलपर्स .onAppear में डेटा लोड करने के आदी हैं, लेकिन async/await और .task के आगमन के साथ, यह दृष्टिकोण पुराना हो गया है। .onAppear कोड को सिंक्रोनस रूप से निष्पादित करता है — .onAppear के अंदर एसिंक्रोनस ऑपरेशन के लिए, कॉल को Task { } में लपेटना और संभावित रद्दीकरण के लिए मैन्युअल रूप से उसका संदर्भ रखना आवश्यक है। .task यह स्वचालित रूप से करता है।

.onAppear अभी भी सिंक्रोनस ऑपरेशन के लिए उपयोगी है — उदाहरण के लिए, लॉगिंग या प्रारंभिक UI सेटअप। लेकिन एसिंक्रोनस डेटा लोडिंग, नेटवर्क अनुरोध, डेटाबेस या फ़ाइल सिस्टम संचालन के लिए .task का उपयोग करें। यह आर्किटेक्चर की दृष्टि से सुरक्षित और स्वच्छ है।

// ❌ पुराना तरीका: .onAppear में बिना रद्दीकरण के Task
var loadTask: Task<Void, Never>?
func body() { var body: some View { Text("") }
    .onAppear {
        loadTask = Task { await loadData() }
    }
    .onDisappear { loadTask?.cancel() }

// ✅ आधुनिक तरीका: .task रद्दीकरण प्रबंधित करता है
func body() { var body: some View { Text("") }
    .task { await loadData() }

.task(id:) — डेटा बदलने पर पुनः प्रारंभ

.task(id:) मॉडिफ़ायर एक अतिरिक्त पैरामीटर — पहचानकर्ता स्वीकार करता है। जब पहचानकर्ता का मान बदलता है, SwiftUI वर्तमान कार्य को रद्द करता है और नए पहचानकर्ता के साथ एक नया कार्य शुरू करता है। यह उन स्क्रीन के लिए आदर्श है जहाँ डेटा किसी चयनित पैरामीटर पर निर्भर करता है — उदाहरण के लिए, श्रेणी के अनुसार लेखों की सूची या ID के अनुसार उत्पाद विवरण।

struct CategoryView: View {
    let categoryId: Int
    @State var items: [Item] = []
    
    var body: some View {
        List(items) { item in
            Text(item.name)
        }
        .task(id: categoryId) {
            await loadItems(for: categoryId)
        }
    }
    
    func loadItems(for id: Int) async {
        do {
            items = await APIClient().fetchItems(categoryId: id)
        } catch {
            // त्रुटि संभालें
        }
    }
}

जब categoryId बदलता है, SwiftUI पिछले अनुरोध को रद्द करता है और नया शुरू करता है। यह तेज़ श्रेणी स्विचिंग के दौरान विशेष रूप से महत्वपूर्ण है — पुराने अनुरोध राज्य अपडेट के लिए नए के साथ प्रतिस्पर्धा नहीं करेंगे। .task(id:) के बिना, आपको .onChange के माध्यम से मैन्युअल रूप से परिवर्तनों को ट्रैक करना और Task को मैन्युअल रूप से प्रबंधित करना होगा।

कार्य रद्दीकरण और isCancelled जाँच

हालाँकि .task View गायब होने पर कार्य को स्वचालित रूप से रद्द करता है, एसिंक्रोनस ऑपरेशन को स्वयं रद्दीकरण की सहकारी जाँच करनी चाहिए। Swift सहकारी रद्दीकरण मॉडल का उपयोग करता है — Task.cancel() निष्पादन को जबरन नहीं रोकता, बल्कि केवल isCancelled फ़्लैग सेट करता है। कार्य के अंदर कोड को समय-समय पर इस फ़्लैग की जाँच करनी चाहिए।

struct LoadingView: View {
    @State var progress: Double = 0
    
    var body: some View {
        ProgressView(value: progress)
            .task {
                for i in 0..<100 {
                    // रद्दीकरण जाँचें
                    try Task.checkCancellation()
                    
                    await Task.sleep(nanoseconds: 50_000_000)
                    progress = Double(i + 1) / 100.0
                }
            }
    }
}

Task.checkCancellation() CancellationError फेंकता है यदि कार्य रद्द कर दिया गया हो। यह जाँच का सबसे सरल तरीका है — यह किसी भी async कॉन्टेक्स्ट में काम करता है। विकल्प महंगे ऑपरेशन से पहले Task.isCancelled को मैन्युअल रूप से जाँचना है। URLSession के लिए, नेटवर्क अनुरोध कार्य रद्द होने पर स्वचालित रूप से रद्द हो जाते हैं, क्योंकि URLSession मूल रूप से Structured Concurrency का समर्थन करता है।

.task के व्यावहारिक उदाहरण

.task कई परिदृश्यों के लिए उपयुक्त है: सरल JSON लोडिंग से TaskGroup के साथ जटिल समानांतर संचालन तक। आइए तीन विशिष्ट उपयोग मामलों को देखें।

त्रुटि प्रबंधन के साथ लोडिंग

struct ProfileView: View {
    @State var profile: Profile?
    @State var isLoading = true
    
    var body: some View {
        Group {
            if isLoading {
                ProgressView()
            } else if let profile {
                Text(profile.name)
            } else {
                Text("लोड करने में विफल")
            }
        }
        .task {
            defer { isLoading = false }
            do {
                profile = await APIClient().fetchProfile()
            } catch {
                // प्रोफ़ाइल nil रहता है
            }
        }
    }
}

TaskGroup के साथ समानांतर लोडिंग

struct DashboardView: View {
    @State var stats: DashboardStats?
    
    var body: some View {
        Text("डैशबोर्ड")
            .task {
                stats = await Task {
                    await withThrowingTaskGroup { group in
                        group.addTask { await API().fetchUsers() }
                        group.addTask { await API().fetchOrders() }
                        group.addTask { await API().fetchRevenue() }
                        
                        return DashboardStats(
                            users: try await group.next(),
                            orders: try await group.next(),
                            revenue: try await group.next()
                        )
                    }
                }.value
            }
    }
}

.task के साथ सामान्य गलतियाँ

सबसे आम गलती मुख्य थ्रेड पर स्विच किए बिना .task के अंदर UI गुणों को बदलना है। हालाँकि SwiftUI async कॉन्टेक्स्ट में @State को संशोधित करते समय स्वचालित रूप से अपडेट को मुख्य थ्रेड पर लौटाता है, .task के अंदर UIKit तत्वों का सीधा हेरफेर क्रैश का कारण बन सकता है।

• try/catch भूल गए — .task त्रुटियों को स्वचालित रूप से नहीं संभालता। सभी थ्रोइंग फ़ंक्शन do/catch में लिपटे होने चाहिए, अन्यथा ऐप क्रैश हो जाएगा।
• डेटा रेस — यदि कई .task(id:) अलग-अलग id के साथ शुरू किए जाते हैं और एक ही राज्य को अपडेट करते हैं, तो डेटा रेस हो सकती हैं। विभिन्न डेटा स्रोतों के लिए अलग-अलग गुणों का उपयोग करें।
• लंबे सिंक्रोनस ऑपरेशन — .task सिंक्रोनस कोड को एसिंक्रोनस नहीं बनाता। यदि .task के अंदर भारी सिंक्रोनस काम है, तो इसे Task.detached में लपेटें या एक अलग async विधि में ले जाएँ।
• CancellationError को अनदेखा करना — Task.checkCancellation() की जाँच करते समय, CancellationError को ऊपर प्रचारित किया जाना चाहिए, दबाया नहीं जाना चाहिए। रद्दीकरण को दबाने से मेमोरी लीक हो सकती है।

// ❌ त्रुटि: कोई त्रुटि प्रबंधन नहीं
.task {
    let data = await fetchData() // त्रुटि होने पर क्रैश!
    items = data
}

// ✅ सही: do/catch
.task {
    do {
        items = await fetchData()
    } catch {
        errorMessage = error.localizedDescription
    }
}