Swift Academy · Lektion

Result mit async/await verbinden

Wandeln Sie auf Callbacks basierende Result-APIs in asynchrone, fehlerwerfende Funktionen um.

Result mit async/await verbinden ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Callback-basierte Legacy-APIs geben `Result` zurück. Moderner Code verwendet async/await. Die Verbindung zwischen beiden ist eine häufige Aufgabe – Swift bietet dafür klare Muster in beide Richtungen.

withCheckedThrowingContinuation

```swift func fetchAsync(url: URL) async throws -> Data { try await withCheckedThrowingContinuation { cont in fetchCallback(url) { result in cont.resume(with: result) } } } ``` `cont.resume(with: result)` akzeptiert direkt ein `Result`.

withCheckedContinuation (ohne Fehlerbehandlung)

```swift func fetchAsync(url: URL) async -> Result { await withCheckedContinuation { cont in fetchCallback(url) { result in cont.resume(returning: result) } } } ```

Async in Result umwandeln

```swift func asResult(of operation: () async throws -> T) async -> Result { do { return .success(try await operation()) } catch { return .failure(error) } } let r = await asResult { try await fetch(url) } ```

Result.get() im asynchronen Kontext

```swift func process() async { let result: Result = await fetchAsync(url) do { let data = try result.get() handle(data) } catch { handle(error) } } ```

Task { } zum Überbrücken

```swift func load() { Task { let data = try await fetchAsync(url) await MainActor.run { self.render(data) } } } ```

AsyncStream aus Callbacks

```swift func events() -> AsyncStream { AsyncStream { cont in let token = subscribe { event in cont.yield(event) } cont.onTermination = { _ in unsubscribe(token) } } } ```

Sicherheitsregeln für Continuations

• Rufen Sie `resume` genau einmal auf – ein zweimaliger Aufruf führt zu undefiniertem Verhalten • Rufen Sie `resume` nicht auf, nachdem die Funktion zurückgegeben wurde • Verwenden Sie `withCheckedContinuation` in Debug-Builds (erkennt Fehler); verwenden Sie bei Bedarf für eine bessere Performance `withUnsafeContinuation` in Release-Builds

MainActor für UI-Aktualisierungen

```swift await MainActor.run { label.text = data.description } // or: @MainActor func updateUI(_ d: Data) { label.text = ... } await updateUI(data) ```

Async+Result testen

```swift func testFetch() async throws { let result = await asResult { try await fetchAsync(url) } switch result { case .success(let d): XCTAssertFalse(d.isEmpty) case .failure(let e): XCTFail(e.localizedDescription) } } ```

Kurzer Test

Welcher Continuation-Typ erkennt in Debug-Builds eine falsche Verwendung wie das doppelte Aufrufen von resume?

Zusammenfassung

Die wichtigsten Erkenntnisse: • `withCheckedThrowingContinuation` verbindet Callbacks mit async throws • `cont.resume(with: result)` akzeptiert direkt ein Result • Verpacken Sie `async throws` mit einer Hilfsfunktion in ein `Result` • Rufen Sie `resume` genau einmal auf • `MainActor.run { }` für sichere UI-Aktualisierungen aus einem asynchronen Kontext Kurs abgeschlossen! Als Nächstes: SwiftUI-Grundlagen.

Häufig gestellte Fragen

Ist die Lektion „Result mit async/await verbinden“ kostenlos?

Ja — der vollständige Text von „Result mit async/await verbinden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Result mit async/await verbinden“?

Wandeln Sie auf Callbacks basierende Result-APIs in asynchrone, fehlerwerfende Funktionen um. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Result mit async/await verbinden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Grundlagen von Result
map und flatMap auf Result
Benutzerdefinierte Fehlertypen mit LocalizedError
Result mit async/await verbinden

← Zurück zu Swift Academy