Swiftのasync/awaitを使ったシンプルな非同期APIコールの実装方法

import Foundation

// 非同期APIコールを行う関数
func fetchData(from url: URL) async throws -> Data {
    // URLSession.shared.data(for:) を使用してデータを非同期に取得
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// 使用例
Task {
    do {
        let url = URL(string: "https://api.example.com/data")!
        let data = try await fetchData(from: url)
        // データの処理
        print("Data received: \(data)")
    } catch {
        // エラーハンドリング
        print("Error fetching data: \(error)")
    }
}

import Foundation

// APIリクエストを行い、デコードされたレスポンスを返す関数
struct ApiResponse: Decodable {
    let id: Int
    let name: String
}

func fetchApiResponse() async throws -> ApiResponse {
    let url = URL(string: "https://api.example.com/data")!

    // 非同期でデータを取得
    let (data, response) = try await URLSession.shared.data(from: url)

    // HTTPレスポンスのステータスコードをチェック
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }

    // 取得したデータをJSONとしてデコード
    let decodedResponse = try JSONDecoder().decode(ApiResponse.self, from: data)

    return decodedResponse
}

Task {
    do {
        let apiResponse = try await fetchApiResponse()
        print("API Response: \(apiResponse)")
    } catch {
        print("Failed to fetch data: \(error)")
    }
}

import Foundation

// 非同期APIコールでエラーが発生した場合に対応する関数
func fetchDataWithHandling(from url: URL) async {
    do {
        let (data, response) = try await URLSession.shared.data(from: url)
        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }
        print("Data received: \(data)")
    } catch {
        print("Error fetching data: \(error.localizedDescription)")
    }
}

import Foundation

// リトライ付きAPIコール関数
func fetchDataWithRetry(from url: URL, retryCount: Int = 3) async throws -> Data {
    var currentAttempt = 0
    var lastError: Error?

    // リトライロジック
    while currentAttempt < retryCount {
        do {
            let (data, response) = try await URLSession.shared.data(from: url)
            guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
                throw URLError(.badServerResponse)
            }
            return data
        } catch {
            lastError = error
            currentAttempt += 1
            print("Retrying... Attempt: \(currentAttempt)")
            // 少し待ってから再試行
            try await Task.sleep(nanoseconds: 1_000_000_000) // 1秒待機
        }
    }

    // すべての試行が失敗した場合、最後のエラーをスロー
    throw lastError ?? URLError(.unknown)
}

// 使用例
Task {
    let url = URL(string: "https://api.example.com/data")!
    do {
        let data = try await fetchDataWithRetry(from: url)
        print("Data received successfully: \(data)")
    } catch {
        print("Failed to fetch data after retries: \(error.localizedDescription)")
    }
}

import Foundation

// 複数のAPIコールを並列に行う関数
func fetchMultipleData() async throws -> (Data, Data) {
    let url1 = URL(string: "https://api.example.com/data1")!
    let url2 = URL(string: "https://api.example.com/data2")!

    // 並列で非同期タスクを開始
    async let data1 = URLSession.shared.data(from: url1).0
    async let data2 = URLSession.shared.data(from: url2).0

    // すべてのタスクが完了するまで待つ
    let result1 = try await data1
    let result2 = try await data2

    return (result1, result2)
}

// 使用例
Task {
    do {
        let (data1, data2) = try await fetchMultipleData()
        print("Data 1: \(data1)")
        print("Data 2: \(data2)")
    } catch {
        print("Error fetching data: \(error)")
    }
}

import Foundation

// TaskGroupを使った並列処理
func fetchMultipleDataWithTaskGroup() async throws -> [Data] {
    let urls = [
        URL(string: "https://api.example.com/data1")!,
        URL(string: "https://api.example.com/data2")!,
        URL(string: "https://api.example.com/data3")!
    ]

    var results: [Data] = []

    // TaskGroupで並列タスクを管理
    try await withThrowingTaskGroup(of: Data.self) { group in
        for url in urls {
            group.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                return data
            }
        }

        // すべてのタスクが終了するまで待機し、結果を収集
        for try await result in group {
            results.append(result)
        }
    }

    return results
}

// 使用例
Task {
    do {
        let dataList = try await fetchMultipleDataWithTaskGroup()
        for data in dataList {
            print("Data: \(data)")
        }
    } catch {
        print("Error fetching data: \(error)")
    }
}

import Foundation

func fetchDataUsingCallback(url: URL, completion: @escaping (Data?, Error?) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            completion(nil, URLError(.badServerResponse))
            return
        }

        if let error = error {
            completion(nil, error)
        } else {
            completion(data, nil)
        }
    }.resume()
}

// 使用例
let url = URL(string: "https://api.example.com/data")!
fetchDataUsingCallback(url: url) { data, error in
    if let data = data {
        print("Data received: \(data)")
    } else if let error = error {
        print("Error: \(error.localizedDescription)")
    }
}

import Foundation

func fetchDataUsingAsyncAwait(from url: URL) async throws -> Data {
    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }

    return data
}

// 使用例
Task {
    do {
        let url = URL(string: "https://api.example.com/data")!
        let data = try await fetchDataUsingAsyncAwait(from: url)
        print("Data received: \(data)")
    } catch {
        print("Error: \(error.localizedDescription)")
    }
}

import Foundation

// モデル定義
struct User: Decodable {
    let id: Int
    let name: String
}

struct UserDetails: Decodable {
    let id: Int
    let email: String
}

struct RelatedData: Decodable {
    let userId: Int
    let data: String
}

// ユーザー情報を取得する非同期関数
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)
    let user = try JSONDecoder().decode(User.self, from: data)
    return user
}

// ユーザーの詳細情報を取得する非同期関数
func fetchUserDetails(userId: Int) async throws -> UserDetails {
    let url = URL(string: "https://api.example.com/user-details/\(userId)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    let userDetails = try JSONDecoder().decode(UserDetails.self, from: data)
    return userDetails
}

// 関連データを取得する非同期関数
func fetchRelatedData(for userId: Int) async throws -> RelatedData {
    let url = URL(string: "https://api.example.com/related-data/\(userId)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    let relatedData = try JSONDecoder().decode(RelatedData.self, from: data)
    return relatedData
}

// 複雑なフローを実行する非同期関数
func fetchUserDataAndRelatedInfo(userId: Int) async throws -> (User, UserDetails, RelatedData) {
    // 1. ユーザー情報を取得
    let user = try await fetchUser(id: userId)

    // 2. ユーザーの詳細情報を取得
    let userDetails = try await fetchUserDetails(userId: user.id)

    // 3. 関連データを取得
    let relatedData = try await fetchRelatedData(for: user.id)

    // 4. 取得したデータを統合して返す
    return (user, userDetails, relatedData)
}

// 使用例
Task {
    do {
        // ユーザーID 1のデータを非同期で取得し、結果を処理
        let (user, userDetails, relatedData) = try await fetchUserDataAndRelatedInfo(userId: 1)
        print("User: \(user.name), Email: \(userDetails.email), Related Data: \(relatedData.data)")
    } catch {
        print("Error fetching data: \(error.localizedDescription)")
    }
}

func fetchUserDataAndRelatedInfoParallel(userId: Int) async throws -> (User, UserDetails, RelatedData) {
    // 1. ユーザー情報を取得
    let user = try await fetchUser(id: userId)

    // 2. ユーザー詳細と関連データを並列で取得
    async let userDetails = fetchUserDetails(userId: user.id)
    async let relatedData = fetchRelatedData(for: user.id)

    // 3. 並列に待機して結果を取得
    return (user, try await userDetails, try await relatedData)
}

import XCTest
@testable import YourApp

class APITests: XCTestCase {

    // 非同期APIコールのテスト
    func testFetchUser() async throws {
        // テスト用のURLを定義
        let url = URL(string: "https://api.example.com/users/1")!

        // 非同期関数をテスト
        let user = try await fetchUser(id: 1)

        // 期待されるユーザー名が取得できているかを確認
        XCTAssertEqual(user.name, "John Doe")
    }
}

import XCTest

// モックURLSessionクラス
class MockURLSession: URLSessionProtocol {
    var testData: Data?

    func data(from url: URL) async throws -> (Data, URLResponse) {
        // モックデータを返す
        let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: nil, headerFields: nil)!
        return (testData ?? Data(), response)
    }
}

// 非同期関数のテストにモックを利用する
class APITestsWithMock: XCTestCase {

    // モックデータを使ったテスト
    func testFetchUserWithMock() async throws {
        // モックデータの準備
        let mockSession = MockURLSession()
        let mockData = """
        {
            "id": 1,
            "name": "John Doe"
        }
        """.data(using: .utf8)!
        mockSession.testData = mockData

        // モックを注入してテスト実行
        let user = try await fetchUser(id: 1, session: mockSession)

        // モックデータに基づくアサーション
        XCTAssertEqual(user.name, "John Doe")
    }
}

func testFetchUserAndDetails() async throws {
    let userId = 1

    // ユーザー情報の取得
    let user = try await fetchUser(id: userId)
    XCTAssertEqual(user.name, "John Doe")

    // ユーザー詳細情報の取得
    let userDetails = try await fetchUserDetails(userId: userId)
    XCTAssertEqual(userDetails.email, "john.doe@example.com")
}

async let data1 = fetchData(from: url1)
async let data2 = fetchData(from: url2)
let result1 = try await data1
let result2 = try await data2

let task1 = Task { try await fetchData(from: url1) }
let task2 = Task { try await fetchData(from: url2) }
let result1 = try await task1.value
let result2 = try await task2.value

do {
    let data = try await fetchData(from: url)
    print("Data received: \(data)")
} catch {
    print("Failed to fetch data: \(error.localizedDescription)")
}

try await withThrowingTaskGroup(of: Data.self) { group in
    for url in urls {
        group.addTask {
            try await fetchData(from: url)
        }
    }

    for try await data in group {
        // 各データを処理
    }
}

Task {
    fetchData(from: url) { data, error in
        // コールバック内での処理
        print("Received data")
    }
    let data = try await fetchData(from: anotherUrl)
}

Task {
    let data1 = try await fetchData(from: url1)
    let data2 = try await fetchData(from: url2)
    print("Both data received")
}

func fetchData(from url: URL) async throws -> Data {
    if Task.isCancelled {
        throw CancellationError()
    }
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

func fetchUserData(userId: Int) async throws -> User {
    // 実装してください
}

func fetchMultipleUsers(userIds: [Int]) async -> [User] {
    // 実装してください
}

func fetchDataWithRetry(from url: URL, retryCount: Int) async throws -> Data {
    // 実装してください
}

func testFetchUserWithMock() async throws {
    // 実装してください
}