.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
    }
}