SwiftUI Fundamentals
Connect Swift concurrency to the view lifecycle with task, explicit loading states, cancellation, retry, and refresh behavior.
Before you begin
Learning stage
The task modifier starts asynchronous work associated with a view's lifetime. SwiftUI can cancel that task when the view disappears or when a task(id:) identifier changes. This is usually a better lifecycle match than starting untracked work from body or init.
Asynchronous UI needs an explicit state model. Loading, content, empty, and failure are different user experiences, not only an optional array and a Boolean. An enum prevents contradictory states and gives each branch the information it requires.
Cancellation is expected control flow. Let cancellation propagate, check it during long work, and avoid replacing useful content with a cancellation error. For input-driven work such as search, task(id:) cancels the prior task as the ID changes; a small delay can provide cooperative debouncing.
Learning stage
The screen owns a model that exposes one complete load state and uses task for lifecycle-aware loading and retry.
import Observation
import SwiftUI
enum LoadState<Value> {
case idle
case loading
case loaded(Value)
case failed(message: String)
}
@MainActor @Observable
final class CatalogModel {
var state: LoadState<[Course]> = .idle
private let client: CourseClient
init(client: CourseClient) { self.client = client }
func load() async {
if case .loading = state { return }
state = .loading
do {
let courses = try await client.fetchCourses()
try Task.checkCancellation()
state = .loaded(courses)
} catch is CancellationError {
return
} catch {
state = .failed(message: "Courses could not be loaded.")
}
}
}
struct CatalogScreen: View {
@State var model: CatalogModel
var body: some View {
CatalogContent(state: model.state, retry: { Task { await model.load() } })
.task { await model.load() }
.refreshable { await model.load() }
}
}Learning stage
Connect the SwiftUI concept to complete, maintainable application features.
Learning stage
Identify patterns that weaken ownership, identity, adaptation, accessibility, or user experience.
Learning stage
Build the behavior in a small Xcode project and review it in multiple states.
Activity 1
Create an enum for idle, loading, loaded, empty, and failed. Render a distinct accessible UI for each and add retry.
Hint: If an empty array has a different meaning from loaded content, represent that meaning deliberately.
Activity 2
Use task(id:) with search text, a short clock delay, and cancellation to prevent stale results.
Hint: After every suspension point, consider whether the task may have become obsolete.
Learning stage
Answer each question before revealing the explanation.
QUESTION 1
It associates asynchronous work with the view lifecycle
SwiftUI starts the task for the view and can cancel it when its lifecycle or task ID changes.
QUESTION 2
No. Cancellation usually means the result became obsolete, not that the user experienced a failure.
Treat expected cancellation separately from errors that require recovery or explanation.
Learning stage
Explain the design in terms of data flow, identity, lifecycle, platform behavior, and trade-offs.
Short answer: Use an injected async client, a main-actor observable model with one load-state enum, and a task tied to the view lifecycle.
The model performs the request and publishes one valid state. The view renders loading, content, empty, or failure branches and exposes retry. task starts work when appropriate, cancellation is treated as expected control flow, and request identity prevents stale results from winning.
Possible follow-ups
Learning stage
Lifecycle-aware async UI requires more than await. Tie work to view identity, represent complete user-facing states, treat cancellation as normal, and prevent obsolete tasks from updating current data.