.task { } — что это, модификатор async и загрузка данных в View

Что такое .task { } в SwiftUI

.task { } — это модификатор View, который создаёт Task в async-контексте при появлении View на экране. SwiftUI запускает переданное замыкание в фоновом потоке, при этом главный поток остаётся свободным для 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 делает это автоматически, что уменьшает количество boilerplate кода и исключает риск забыть отменить задачу.

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: ключевые отличия

Многие разработчики привыкли загружать данные в .onAppear, но с появлением async/await и .task этот подход устарел. .onAppear выполняет код синхронно — для асинхронных операций внутри .onAppear нужно оборачивать вызов в Task { } и вручную сохранять ссылку на него для возможной отмены. .task делает это автоматически.

.onAppear всё ещё полезен для синхронных операций — например, логирования или начальной настройки UI. Но для асинхронной загрузки данных, сетевых запросов, работы с базой данных или файловой системой используй .task. Это безопаснее и чище с точки зрения архитектуры.

// ❌ Legacy approach: Task in .onAppear without cancellation
var loadTask: Task<Void, Never>?
func body() { var body: some View { Text("") }
    .onAppear {
        loadTask = Task { await loadData() }
    }
    .onDisappear { loadTask?.cancel() }

// ✅ Modern approach: .task manages cancellation
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 {
            // handle error
        }
    }
}

Когда 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 {
                    // Check cancellation
                    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("Failed to load")
            }
        }
        .task {
            defer { isLoading = false }
            do {
                profile = await APIClient().fetchProfile()
            } catch {
                // profile stays nil
            }
        }
    }
}

Параллельная загрузка с 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
            }
    }
}

Типичные ошибки с .task

Наиболее распространённая ошибка — мутация UI-свойств внутри .task без переключения на главный поток. Хотя SwiftUI автоматически возвращает обновления на главный поток при изменении @State в async-контексте, прямые манипуляции с UIKit-элементами внутри .task могут вызвать crash.

• Забыл try/catch — .task не обрабатывает ошибки автоматически. Все выбрасывающие функции внутри должны быть обёрнуты в do/catch, иначе приложение упадёт.
• Гонка данных (race condition) — если несколько .task(id:) запущены с разными id и обновляют один и тот же state, возможны гонки. Используй отдельные свойства для разных источников данных.
• Долгие синхронные операции — .task не делает синхронный код асинхронным. Если внутри .task есть тяжёлая синхронная работа, оберни её в Task.detached или перенеси в отдельный async-метод.
• Игнорирование CancellationError — при проверке Task.checkCancellation() ошибка CancellationError должна пробрасываться наверх, а не подавляться. Подавление отмены может привести к утечке памяти.

// ❌ Error: no error handling
.task {
    let data = await fetchData() // crashes on error!
    items = data
}

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