.task und @MainActor

Das Problem: Wann und wo wird geladen?

In der letzten Lektion hast du Task { ... } kennengelernt. Damit kannst du aus einem Button heraus asynchron laden. Aber oft soll das Laden automatisch passieren, sobald ein Bildschirm erscheint. Naheliegend wäre:

.onAppear {
    Task {
        await loadData()
    }
}

Das funktioniert, hat aber zwei Probleme:

1. Verlässt der Nutzer den Bildschirm, bevor das Laden fertig ist, läuft die Aufgabe trotzdem weiter. Sie verschwendet Akku und Datenvolumen, und ihr Ergebnis landet womöglich in einer View, die es gar nicht mehr gibt.
2. Und wo genau wird das Ergebnis eigentlich in die Oberfläche geschrieben? Auf welchem Thread?

Für beides hat SwiftUI eine elegante Lösung.

.task: Laden an die View gekoppelt

struct QuoteView: View {
    @State private var quote = "Lädt…"

    var body: some View {
        Text(quote)
            .padding()
            .task {
                quote = await loadQuote()
            }
    }
}

func loadQuote() async -> String {
    try? await Task.sleep(for: .seconds(1))
    return "Jeder Profi war einmal Anfänger."
}

.task { ... } ist ein Modifier, der:

• seine Closure asynchron startet, sobald die View erscheint. Du darfst darin direkt await verwenden.
• die Aufgabe automatisch abbricht, wenn die View verschwindet.

Das ist der Standardweg, um in SwiftUI Daten zu laden. Kein Task, kein onAppear, kein manuelles Abbrechen.

Neu laden, wenn sich etwas ändert

Oft hängt das, was geladen wird, von einem Wert ab, etwa einer ausgewählten Kategorie. Ändert sich der Wert, soll neu geladen werden:

struct CategoryView: View {
    @State private var category = "Pasta"
    @State private var recipes: [String] = []

    var body: some View {
        VStack {
            Picker("Kategorie", selection: $category) {
                Text("Pasta").tag("Pasta")
                Text("Suppen").tag("Suppen")
                Text("Desserts").tag("Desserts")
            }
            .pickerStyle(.segmented)

            List(recipes, id: \.self) { Text($0) }
        }
        .task(id: category) {
            recipes = await loadRecipes(for: category)
        }
    }
}

.task(id: category) läuft beim Erscheinen und jedes Mal, wenn sich category ändert. Läuft gerade noch ein alter Ladevorgang, wird er abgebrochen, bevor der neue startet. Wechselt der Nutzer schnell zwischen Kategorien, werden alte, nicht mehr gebrauchte Anfragen also automatisch verworfen.

Der Main Thread

Jetzt zur zweiten Frage: Auf welchem Thread läuft das alles?

Jede App hat einen besonderen Thread, den Main Thread (Hauptthread). Auf ihm läuft alles, was mit der Oberfläche zu tun hat: Views zeichnen, auf Tippen reagieren, animieren. Eine eiserne Regel lautet:

Die Oberfläche darf nur vom Main Thread aus verändert werden.

Würden zwei Threads gleichzeitig an der Oberfläche arbeiten, könnte das zu Darstellungsfehlern oder Abstürzen führen. Gleichzeitig darf der Main Thread nicht mit langer Arbeit blockiert werden, sonst friert die App ein (Lektion 3.6).

Also: Langsame Arbeit neben dem Main Thread, Ergebnisse auf dem Main Thread in die Oberfläche schreiben.

@MainActor

Swift drückt „läuft auf dem Main Thread“ mit @MainActor aus. Ein Actor ist, vereinfacht gesagt, ein geschützter Bereich, in dem immer nur ein Stück Code gleichzeitig läuft. Der Main Actor ist der Bereich des Main Threads.

Das Gute: SwiftUI-Views sind bereits @MainActor. Alles, was du in body, in Button-Aktionen und in .task schreibst, läuft auf dem Main Actor. Deshalb durftest du oben einfach quote = await loadQuote() schreiben: Das Zuweisen passiert auf dem Main Thread.

Wartet .task mit await auf eine Funktion, gibt es den Main Thread frei, solange es wartet. Die App bleibt flüssig. Kommt das Ergebnis, geht es auf dem Main Thread weiter.

ViewModels mit @MainActor

Lagerst du das Laden in ein ViewModel aus (Lektion 3.5), schreibt dieses ViewModel Werte, die die Oberfläche liest. Deshalb markierst du es mit @MainActor:

@MainActor
@Observable
class QuoteViewModel {
    var quote = "Lädt…"
    var isLoading = false

    func load() async {
        isLoading = true
        quote = await loadQuote()
        isLoading = false
    }
}

struct QuoteScreen: View {
    @State private var viewModel = QuoteViewModel()

    var body: some View {
        VStack(spacing: 16) {
            if viewModel.isLoading {
                ProgressView()
            }
            Text(viewModel.quote)
        }
        .task {
            await viewModel.load()
        }
    }
}

• @MainActor vor der Klasse sagt: „Alle Eigenschaften und Methoden dieser Klasse gehören auf den Main Actor.“ Damit ist garantiert, dass quote und isLoading nur vom Main Thread aus geändert werden.
• ProgressView() ohne Parameter zeigt den bekannten drehenden Ladekreis.
• Die View ruft mit .task { await viewModel.load() } die asynchrone Methode auf.

Laden mit Knopfdruck

Nicht alles soll automatisch geladen werden. Für Aktionen des Nutzers verwendest du Task in der Button-Aktion:

Button("Neuer Spruch") {
    Task {
        await viewModel.load()
    }
}
.disabled(viewModel.isLoading)

.disabled(viewModel.isLoading) verhindert, dass der Nutzer mehrmals hintereinander tippt und mehrere Ladevorgänge gleichzeitig startet.

Ein vollständiges Muster

So sieht ein typischer Bildschirm aus, der beim Erscheinen lädt, einen Ladezustand zeigt, Fehler behandelt und neu laden kann:

enum QuoteError: Error {
    case unavailable
}

func fetchQuote() async throws -> String {
    try await Task.sleep(for: .seconds(1))
    if Bool.random() { throw QuoteError.unavailable }
    return "Kleine Schritte sind auch Schritte."
}

@MainActor
@Observable
class QuoteLoader {
    var quote: String?
    var errorMessage: String?
    var isLoading = false

    func load() async {
        isLoading = true
        errorMessage = nil
        defer { isLoading = false }

        do {
            quote = try await fetchQuote()
        } catch {
            errorMessage = "Der Spruch konnte nicht geladen werden."
        }
    }
}

struct QuoteLoaderView: View {
    @State private var loader = QuoteLoader()

    var body: some View {
        VStack(spacing: 20) {
            if loader.isLoading {
                ProgressView("Lädt…")
            } else if let quote = loader.quote {
                Text(quote)
                    .font(.title2)
                    .multilineTextAlignment(.center)
            } else if let message = loader.errorMessage {
                Text(message)
                    .foregroundStyle(.red)
            }

            Button("Neu laden") {
                Task { await loader.load() }
            }
            .disabled(loader.isLoading)
        }
        .padding()
        .task {
            await loader.load()
        }
    }
}

• defer { isLoading = false } läuft garantiert am Ende der Funktion, egal ob mit Erfolg oder Fehler (Lektion 1.17, 🟡-FAQ). So bleibt der Ladekreis nie hängen.
• Die View beschreibt für jeden Zustand, was zu sehen ist.

Mit drei getrennten Eigenschaften quote, errorMessage und isLoading können allerdings widersprüchliche Kombinationen entstehen. In Lektion 3.11 machst du daraus ein sauberes Enum.

Typische Fehler

Task in .onAppear statt .task

Funktioniert, bricht aber nicht ab, wenn die View verschwindet. Nimm .task.

ViewModel ohne @MainActor

Je nach Projekteinstellung meldet Xcode Warnungen oder Fehler wie:

oder, ohne Prüfung durch den Compiler, zur Laufzeit eine violette Warnung: Publishing changes from background threads is not allowed. Markiere ViewModels, die Oberflächenzustand halten, mit @MainActor.

Mehrfaches Laden

Ein Button startet bei jedem Tipp einen neuen Ladevorgang. Deaktiviere ihn, solange geladen wird.

.task wird mehrfach ausgeführt

.task läuft jedes Mal, wenn die View erscheint, also auch beim Zurücknavigieren zu ihr. Soll nur einmal geladen werden, prüf zuerst, ob schon Daten da sind: guard loader.quote == nil else { return }.

FAQ

Übungen

struct WelcomeView: View {
    @State private var message: String?

    var body: some View {
        Group {
            if let message {
                Text(message).font(.title)
            } else {
                ProgressView()
            }
        }
        .task {
            try? await Task.sleep(for: .seconds(2))
            message = "Willkommen zurück!"
        }
    }
}

Zusammenfassung

• .task { ... } startet asynchrone Arbeit, wenn eine View erscheint, und bricht sie automatisch ab, wenn sie verschwindet.
• .task(id: wert) startet bei jeder Änderung des Werts neu und bricht alte Vorgänge ab.
• Die Oberfläche darf nur vom Main Thread aus geändert werden.
• SwiftUI-Views sind @MainActor. ViewModels, die Oberflächenzustand halten, markierst du ebenfalls mit @MainActor.
• Aus Buttons startest du asynchrone Arbeit mit Task { ... } und deaktivierst sie währenddessen.
• ProgressView zeigt, dass etwas lädt. defer setzt Ladezustände zuverlässig zurück.

Spickzettel

.task {
    await viewModel.load()
}

.task(id: selection) {
    items = await load(selection)
}

@MainActor
@Observable
class Loader {
    var isLoading = false
    func load() async {
        isLoading = true
        defer { isLoading = false }
        ...
    }
}

Button("Neu laden") { Task { await loader.load() } }
    .disabled(loader.isLoading)