Async/Await trong Swift

func fetchData() async -> String {
    // Simulate network delay
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    return "Data loaded!"
}
 
// Gọi async function
func loadData() async {
    let data = await fetchData()
    print(data)
}

enum NetworkError: Error {
    case invalidURL
    case serverError
}
 
func fetchUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// Trong async context
func example() async {
    let data = await fetchData()
    print(data)
}
 
// Từ synchronous code
Task {
    let data = await fetchData()
    print(data)
}

func fetchAllData() async {
    async let user = fetchUser()
    async let posts = fetchPosts()
    async let comments = fetchComments()
    
    // Chạy song song
    let (u, p, c) = await (user, posts, comments)
    print(u, p, c)
}

func fetchMultipleUsers(ids: [Int]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in ids {
            group.addTask {
                try await fetchUser(id: id)
            }
        }
        
        var users: [User] = []
        for try await user in group {
            users.append(user)
        }
        return users
    }
}

@MainActor
class ViewModel: ObservableObject {
    @Published var data: String = ""
    
    func loadData() async {
        let result = await fetchData()
        data = result  // Safe UI update
    }
}
 
// Hoặc inline
func updateUI() async {
    let data = await fetchData()
    await MainActor.run {
        // Update UI
    }
}

actor Counter {
    private var count = 0
    
    func increment() {
        count += 1
    }
    
    func getCount() -> Int {
        count
    }
}
 
let counter = Counter()
await counter.increment()
print(await counter.getCount())

// Convert callback to async
func fetchDataAsync() async -> String {
    await withCheckedContinuation { continuation in
        fetchDataWithCallback { result in
            continuation.resume(returning: result)
        }
    }
}
 
// Throwing version
func fetchThrowingAsync() async throws -> String {
    try await withCheckedThrowingContinuation { continuation in
        fetchWithCallback { result, error in
            if let error = error {
                continuation.resume(throwing: error)
            } else {
                continuation.resume(returning: result!)
            }
        }
    }
}

func fetchNumbers() -> AsyncStream<Int> {
    AsyncStream { continuation in
        for i in 1...5 {
            continuation.yield(i)
        }
        continuation.finish()
    }
}
 
// Usage
Task {
    for await number in fetchNumbers() {
        print(number)
    }
}