0Pricing
Swift Academy · Lezione

Collegare Result ad async/await

Convertire API basate su callback e Result in funzioni async che generano errori.

Collegare Result ad async/await è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Benvenuto

Le API legacy basate su callback restituiscono `Result`. Il codice moderno usa async/await. Adattare l'uno all'altro è un'attività comune: Swift offre pattern chiari in entrambe le direzioni.

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)` accetta direttamente un `Result`.

withCheckedContinuation (senza generazione di errori)

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

Convertire async in Result

```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() in un contesto async

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

Task { } per l'adattamento

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

AsyncStream dai callback

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

Regole di sicurezza per le continuation

• Chiami `resume` esattamente una volta: chiamarlo due volte produce un comportamento non definito • Non chiami `resume` dopo che la funzione ha restituito il risultato • Utilizzi `withCheckedContinuation` in modalità debug (rileva gli errori); utilizzi `withUnsafeContinuation` in release se necessario per le prestazioni

MainActor per aggiornare l'interfaccia utente

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

Test di Async+Result

```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) } } ```

Verifica rapida

Quale tipo di continuation rileva un uso improprio, come una doppia ripresa, nelle build di debug?

Riepilogo

Concetti chiave: • `withCheckedThrowingContinuation` collega le callback al modello `async throws` • `cont.resume(with: result)` accetta direttamente un `Result` • Racchiuda `async throws` in un `Result` con una funzione di supporto • Chiami `resume` esattamente una volta • `MainActor.run { }` consente di aggiornare l'interfaccia utente in sicurezza da un contesto asincrono Corso completato! Prossimo argomento: nozioni di base di SwiftUI.

Domande Frequenti

La lezione «Collegare Result ad async/await» è gratuita?

Sì — il testo completo di «Collegare Result ad async/await» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Collegare Result ad async/await»?

Convertire API basate su callback e Result in funzioni async che generano errori. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Collegare Result ad async/await»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Fondamenti di Result
  2. map e flatMap su Result
  3. Tipi di errore personalizzati con LocalizedError
  4. Collegare Result ad async/await
← Torna a Swift Academy