.task { } — چیست، اصلاح‌کننده async و بارگذاری داده‌ها در View

.task { } در SwiftUI چیست

.task { } — اصلاح‌کننده View است که هنگام ظاهر شدن View روی صفحه، یک Task در زمینه async ایجاد می‌کند. SwiftUI closure داده شده را در پس‌زمینه اجرا می‌کند، در حالی که نخ اصلی برای عملیات UI آزاد می‌ماند. هنگامی که View ناپدید می‌شود، SwiftUI به طور خودکار Task را از طریق مکانیزم Structured Concurrency لغو می‌کند — این تضمین می‌کند که عملیات ناهمگام پس از عدم نیاز کسی به نتیجه آن ادامه نخواهد یافت.

به گفته Apple — Swift Programming Language (2025)، .task از مفهوم Structured Concurrency معرفی شده در Swift 5.5 استفاده می‌کند. هر .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 استفاده کنید. این از نظر معماری امن‌تر و تمیزتر است.

// ❌ رویکرد قدیمی: Task در .onAppear بدون لغو
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 درخواست قبلی را لغو کرده و درخواست جدیدی راه‌اندازی می‌کند. این به ویژه هنگام جابجایی سریع بین دسته‌بندی‌ها مهم است — درخواست‌های قدیمی برای به‌روزرسانی state با درخواست‌های جدید رقابت نخواهند کرد. بدون .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

رایج‌ترین اشتباه — تغییر ویژگی‌های UI درون .task بدون جابجایی به نخ اصلی. اگرچه SwiftUI به طور خودکار به‌روزرسانی‌ها را هنگام تغییر @State در زمینه async به نخ اصلی بازمی‌گرداند، دستکاری مستقیم عناصر UIKit درون .task می‌تواند باعث crash شود.

• فراموشی try/catch — .task خطاها را به طور خودکار مدیریت نمی‌کند. تمام توابع پرتاب‌کننده درون آن باید در do/catch پیچیده شوند، در غیر این صورت برنامه crash می‌کند.
• شرایط رقابتی (race condition) — اگر چند .task(id:) با idهای مختلف راه‌اندازی شده و همان state را به‌روزرسانی کنند، رقابت ممکن است. از ویژگی‌های جداگانه برای منابع داده مختلف استفاده کنید.
• عملیات‌های همگام طولانی — .task کد همگام را ناهمگام نمی‌کند. اگر درون .task کار همگام سنگینی وجود دارد، آن را در Task.detached بپیچید یا به یک متد async جداگانه منتقل کنید.
• نادیده گرفتن CancellationError — هنگام بررسی Task.checkCancellation() خطای CancellationError باید به بالا منتقل شود، نه سرکوب. سرکوب لغو می‌تواند منجر به نشت حافظه شود.

// ❌ خطا: بدون مدیریت خطا
.task {
    let data = await fetchData() // در خطا crash می‌کند!
    items = data
}

// ✅ صحیح: do/catch
.task {
    do {
        items = await fetchData()
    } catch {
        errorMessage = error.localizedDescription
    }
}