.task { } — co to je, modifikátor async a načítání dat ve View

Co je .task { } ve SwiftUI

.task { } — je modifikátor View, který vytváří Task v kontextu async při objevení View na obrazovce. SwiftUI spouští předané closure na pozadí, zatímco hlavní vlákno zůstává volné pro UI operace. Když View zmizí, SwiftUI automaticky ruší Task prostřednictvím mechanismu Structured Concurrency — to zaručuje, že asynchronní operace nebude pokračovat poté, co její výsledek již není nikomu potřebný.

Podle Apple — Swift Programming Language (2025) používá .task koncept Structured Concurrency, zavedený ve Swift 5.5. Každý .task vytváří podřízenou úlohu v rámci úlohy nadřazeného View. Pokud je nadřazená úloha zrušena (View zmizí), všechny podřízené úlohy jsou také automaticky zrušeny. To radikálně zjednodušuje správu životního cyklu asynchronních operací ve srovnání s ručním ukládáním referencí na DispatchWorkItem nebo AnyCancellable.

Na rozdíl od tradičního přístupu s @State + ručním voláním v .onAppear, .task nevyžaduje ukládání reference na Task pro pozdější zrušení. SwiftUI to dělá automaticky, což snižuje množství boilerplate kódu a eliminuje riziko zapomenutí zrušit úlohu.

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 vs .onAppear: klíčové rozdíly

Mnoho vývojářů je zvyklých načítat data v .onAppear, ale s příchodem async/await a .task je tento přístup zastaralý. .onAppear provádí kód synchronně — pro asynchronní operace uvnitř .onAppear je třeba zabalit volání do Task { } a ručně ukládat referenci na něj pro případné zrušení. .task to dělá automaticky.

.onAppear je stále užitečný pro synchronní operace — například logování nebo počáteční konfiguraci UI. Ale pro asynchronní načítání dat, síťové požadavky, práci s databází nebo souborovým systémem používej .task. Je to bezpečnější a čistší z architektonického hlediska.

// ❌ Starý přístup: Task v .onAppear bez zrušení
var loadTask: Task<Void, Never>?
func body() { var body: some View { Text("") }
    .onAppear {
        loadTask = Task { await loadData() }
    }
    .onDisappear { loadTask?.cancel() }

// ✅ Moderní přístup: .task spravuje zrušení
func body() { var body: some View { Text("") }
    .task { await loadData() }

.task(id:) — restart při změně dat

Modifikátor .task(id:) přijímá další parametr — identifikátor. Když se hodnota identifikátoru změní, SwiftUI zruší aktuální úlohu a spustí novou s novým identifikátorem. To je ideální pro obrazovky, kde data závisí na vybraném parametru — například seznam článků podle kategorie nebo detaily produktu podle 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 {
            // ošetři chybu
        }
    }
}

Když se categoryId změní, SwiftUI zruší předchozí požadavek a spustí nový. To je důležité zejména při rychlém přepínání kategorií — staré požadavky nebudou soutěžit s novými o aktualizaci stavu. Bez .task(id:) byste museli ručně sledovat změny přes .onChange a ručně spravovat Task.

Rušení úloh a kontrola isCancelled

Ačkoli .task automaticky ruší úlohu při zmizení View, samotná asynchronní operace musí kooperativně kontrolovat zrušení. Swift používá kooperativní model rušení — Task.cancel() nezastavuje provádění násilně, ale pouze nastavuje příznak isCancelled. Kód uvnitř úlohy by měl tento příznak pravidelně kontrolovat.

struct LoadingView: View {
    @State var progress: Double = 0
    
    var body: some View {
        ProgressView(value: progress)
            .task {
                for i in 0..<100 {
                    // Zkontrolovat zrušení
                    try Task.checkCancellation()
                    
                    await Task.sleep(nanoseconds: 50_000_000)
                    progress = Double(i + 1) / 100.0
                }
            }
    }
}

Task.checkCancellation() vyhazuje CancellationError, pokud byla úloha zrušena. Toto je nejjednodušší způsob kontroly — funguje v jakémkoli async kontextu. Alternativa — ruční kontrola Task.isCancelled před nákladnými operacemi. Pro URLSession jsou síťové požadavky automaticky zrušeny při zrušení úlohy, protože URLSession podporuje Structured Concurrency od základu.

Praktické příklady .task

.task je vhodný pro mnoho scénářů: od jednoduchého načítání JSON po složité paralelní operace s TaskGroup. Podívejme se na tři typické příklady použití.

Načítání s ošetřením chyb

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("Načtení selhalo")
            }
        }
        .task {
            defer { isLoading = false }
            do {
                profile = await APIClient().fetchProfile()
            } catch {
                // profil zůstává nil
            }
        }
    }
}

Paralelní načítání s TaskGroup

struct DashboardView: View {
    @State var stats: DashboardStats?
    
    var body: some View {
        Text("Dashboard")
            .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
            }
    }
}

Typické chyby s .task

Nejčastější chyba — mutace UI vlastností uvnitř .task bez přepnutí na hlavní vlákno. Ačkoli SwiftUI automaticky vrací aktualizace na hlavní vlákno při změně @State v async kontextu, přímé manipulace s UIKit prvky uvnitř .task mohou způsobit crash.

• Zapomněl jsi try/catch — .task nezpracovává chyby automaticky. Všechny funkce vyhazující chyby uvnitř musí být zabaleny do do/catch, jinak aplikace spadne.
• Race condition — pokud je několik .task(id:) spuštěno s různými id a aktualizuje stejný stav, jsou možné race condition. Používej oddělené vlastnosti pro různé zdroje dat.
• Dlouhé synchronní operace — .task nedělá synchronní kód asynchronním. Pokud je uvnitř .task těžká synchronní práce, zabal ji do Task.detached nebo ji přesuň do samostatné async metody.
• Ignorování CancellationError — při kontrole Task.checkCancellation() by měla být chyba CancellationError propagována nahoru, nikoli potlačena. Potlačení zrušení může vést k únikům paměti.

// ❌ Chyba: žádné ošetření chyb
.task {
    let data = await fetchData() // při chybě spadne!
    items = data
}

// ✅ Správně: do/catch
.task {
    do {
        items = await fetchData()
    } catch {
        errorMessage = error.localizedDescription
    }
}