Async Await | Concurrency | Swift Tutorial

Introduction

Async/Await is a powerful feature introduced in Swift 5.5 that simplifies asynchronous programming by allowing developers to write asynchronous code that looks similar to synchronous code. This feature helps in making the code easier to read and maintain.

Understanding Asynchronous Programming

Asynchronous programming allows a program to perform tasks concurrently without blocking the main thread. This is particularly useful for operations that take time, such as network requests or file I/O. Traditionally, asynchronous code in Swift was managed using closures and completion handlers, which could become cumbersome and lead to "callback hell."

What is Async/Await?

The async/await pattern allows you to write asynchronous code in a more straightforward way. By marking functions as async, you indicate that they are asynchronous and may contain await expressions, which pause the execution until the awaited task is complete.

Basic Syntax

Here’s the basic syntax for defining and using async/await in Swift.

Defining an Async Function:

func fetchData() async -> String {
let data = await someNetworkCall()
return data
}

Calling an Async Function:

Task {
let result = await fetchData()
print(result)
}

Example of Async/Await

Let’s see a more complete example that fetches JSON data from a URL using async/await.

Fetching JSON Data:

import Foundation

func fetchJSON(url: URL) async throws -> [String: Any] {
  let (data, _) = try await URLSession.shared.data(from: url)
  let json = try JSONSerialization.jsonObject(with: data, options: [])
  return json as? [String: Any] ?? [:]
}

Task {
  do {
    let url = URL(string: "https://api.example.com/data")!
    let jsonData = try await fetchJSON(url: url)
    print(jsonData)
  } catch {
    print("Error: \\(error)")
  }
}

Handling Errors

When using async/await, you can handle errors using do-catch blocks. If an asynchronous function throws an error, it can be caught in the surrounding do block.

Conclusion

The async/await pattern in Swift greatly enhances the readability and maintainability of asynchronous code. By allowing developers to write asynchronous code in a synchronous style, it reduces the complexity associated with traditional asynchronous programming techniques.

Async/Await in Swift