Swiftで非同期処理とエラーハンドリングを効率的に組み合わせる方法

enum NetworkError: Error {
    case invalidURL
    case requestFailed
}

func fetchData(from url: String) throws {
    guard url == "https://example.com" else {
        throw NetworkError.invalidURL
    }
    // リクエスト成功の処理
}

do {
    try fetchData(from: "https://example.com")
    print("データ取得成功")
} catch NetworkError.invalidURL {
    print("無効なURLです")
} catch {
    print("その他のエラーが発生しました")
}

func fetchData(completion: @escaping (Result<String, Error>) -> Void) {
    let isSuccess = Bool.random()
    if isSuccess {
        completion(.success("データ取得成功"))
    } else {
        completion(.failure(NetworkError.requestFailed))
    }
}

fetchData { result in
    switch result {
    case .success(let data):
        print(data)
    case .failure(let error):
        print("エラーが発生しました: \(error)")
    }
}

func fetchData() async throws -> String {
    let isSuccess = Bool.random()
    if isSuccess {
        return "データ取得成功"
    } else {
        throw NetworkError.requestFailed
    }
}

Task {
    do {
        let data = try await fetchData()
        print(data)
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

func fetchData() async -> String {
    // 非同期処理をシミュレート
    return "データ取得成功"
}

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

func fetchUserData(from url: String) async throws -> User {
    let (data, _) = try await URLSession.shared.data(from: URL(string: url)!)
    let user = try JSONDecoder().decode(User.self, from: data)
    return user
}

Task {
    do {
        let user = try await fetchUserData(from: "https://example.com/user")
        print("ユーザー名: \(user.name)")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

func fetchData() async throws -> String {
    let isSuccess = Bool.random()
    if isSuccess {
        return "データ取得成功"
    } else {
        throw NetworkError.requestFailed
    }
}

Task {
    do {
        let result = try await fetchData()
        print(result)
    } catch NetworkError.requestFailed {
        print("ネットワークリクエストが失敗しました")
    } catch {
        print("その他のエラーが発生しました: \(error)")
    }
}

do {
    let data = try await fetchData()
    print("取得したデータ: \(data)")
} catch NetworkError.invalidURL {
    print("無効なURLです")
} catch NetworkError.requestFailed {
    print("リクエストが失敗しました")
} catch {
    print("不明なエラーが発生しました: \(error)")
}

func performNetworkRequest() async throws -> String {
    let isSuccess = Bool.random()
    if isSuccess {
        return "データ取得成功"
    } else {
        throw NetworkError.requestFailed
    }
}

Task {
    do {
        let result = try await performNetworkRequest()
        print(result)
    } catch NetworkError.requestFailed {
        print("ネットワークリクエストが失敗しました")
    } catch {
        print("不明なエラーが発生しました: \(error)")
    }
}

func fetchData() async throws -> String {
    try Task.checkCancellation() // キャンセルチェック
    // 非同期処理
    return "データ取得成功"
}

let task = Task {
    do {
        let result = try await fetchData()
        print(result)
    } catch is CancellationError {
        print("タスクがキャンセルされました")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

// タスクをキャンセル
task.cancel()

func fetchUserData() async throws -> String {
    return "ユーザーデータ取得"
}

func fetchPostData() async throws -> String {
    return "投稿データ取得"
}

Task {
    async let userData = fetchUserData()
    async let postData = fetchPostData()

    do {
        let (user, post) = try await (userData, postData)
        print("ユーザー: \(user), 投稿: \(post)")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

enum TimeoutError: Error {
    case timeout
}

func performNetworkRequest() async throws -> String {
    // 非同期のネットワークリクエスト処理をシミュレート
    try await Task.sleep(nanoseconds: 3 * 1_000_000_000) // 3秒の待機
    return "データ取得成功"
}

Task {
    do {
        let result = try await withTimeout(seconds: 5) {
            try await performNetworkRequest()
        }
        print(result)
    } catch TimeoutError.timeout {
        print("リクエストがタイムアウトしました")
    } catch {
        print("他のエラーが発生しました: \(error)")
    }
}

// タイムアウト処理を定義
func withTimeout<T>(seconds: UInt64, task: @escaping () async throws -> T) async throws -> T {
    let timeout = Task {
        try await Task.sleep(nanoseconds: seconds * 1_000_000_000)
        throw TimeoutError.timeout
    }

    return try await withTaskGroup(of: T.self) { group in
        group.addTask { try await task() }
        group.addTask { try await timeout.value }
        guard let result = await group.next() else {
            throw TimeoutError.timeout
        }
        return result
    }
}

func fetchDataWithTimeout() async throws -> String {
    let result = try await withTimeout(seconds: 3) {
        try await performNetworkRequest()
    }
    return result
}

Task {
    do {
        let data = try await fetchDataWithTimeout()
        print("データ取得成功: \(data)")
    } catch TimeoutError.timeout {
        print("タイムアウトエラーが発生しました")
    } catch {
        print("他のエラーが発生しました: \(error)")
    }
}

Task {
    do {
        let data = try await fetchDataWithTimeout()
        print("データ取得成功: \(data)")
    } catch TimeoutError.timeout {
        // ユーザーにタイムアウトを通知し、再試行を促す
        print("リクエストがタイムアウトしました。再試行してください。")
    } catch {
        print("予期しないエラーが発生しました: \(error)")
    }
}

func fetchUserData() async throws -> String {
    // 非同期でユーザーデータを取得
    return "ユーザーデータ取得"
}

func fetchPostData() async throws -> String {
    // 非同期で投稿データを取得
    return "投稿データ取得"
}

Task {
    do {
        async let userData = fetchUserData()
        async let postData = fetchPostData()

        let (user, post) = try await (userData, postData)
        print("ユーザー: \(user), 投稿: \(post)")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

func fetchDataFromMultipleSources() async throws -> [String] {
    var results: [String] = []

    try await withThrowingTaskGroup(of: String.self) { group in
        group.addTask { try await fetchUserData() }
        group.addTask { try await fetchPostData() }

        for try await result in group {
            results.append(result)
        }
    }
    return results
}

Task {
    do {
        let data = try await fetchDataFromMultipleSources()
        print("取得したデータ: \(data)")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

Task {
    async let userTask = Task { () throws -> String in
        do {
            return try await fetchUserData()
        } catch {
            throw NetworkError.userDataFailed
        }
    }

    async let postTask = Task { () throws -> String in
        do {
            return try await fetchPostData()
        } catch {
            throw NetworkError.postDataFailed
        }
    }

    do {
        let (user, post) = try await (userTask.value, postTask.value)
        print("ユーザー: \(user), 投稿: \(post)")
    } catch NetworkError.userDataFailed {
        print("ユーザーデータの取得に失敗しました")
    } catch NetworkError.postDataFailed {
        print("投稿データの取得に失敗しました")
    } catch {
        print("予期しないエラーが発生しました: \(error)")
    }
}

func fetchWithCancelableTasks() async throws -> [String] {
    var results: [String] = []

    try await withThrowingTaskGroup(of: String.self) { group in
        group.addTask {
            try await Task.sleep(nanoseconds: 2_000_000_000) // 2秒待機
            return "タスク1完了"
        }

        group.addTask {
            try await Task.sleep(nanoseconds: 1_000_000_000) // 1秒待機
            throw NetworkError.requestFailed
        }

        for try await result in group {
            results.append(result)
        }
    }

    return results
}

Task {
    do {
        let result = try await fetchWithCancelableTasks()
        print(result)
    } catch {
        print("タスクグループ内でエラーが発生しました: \(error)")
    }
}

enum NetworkError: Error {
    case invalidURL
    case requestFailed
    case unauthorized
    case timeout
}

func performNetworkRequest() async throws -> String {
    let isSuccess = Bool.random()
    if !isSuccess {
        throw NetworkError.requestFailed
    }
    return "リクエスト成功"
}

Task {
    do {
        let result = try await performNetworkRequest()
        print(result)
    } catch NetworkError.invalidURL {
        print("URLが無効です")
    } catch NetworkError.requestFailed {
        print("リクエストに失敗しました")
    } catch NetworkError.unauthorized {
        print("認証が必要です")
    } catch NetworkError.timeout {
        print("リクエストがタイムアウトしました")
    } catch {
        print("その他のエラーが発生しました: \(error)")
    }
}

func fetchDataWithRetry() async throws -> String {
    var attempts = 0
    let maxAttempts = 3

    while attempts < maxAttempts {
        do {
            return try await performNetworkRequest()
        } catch NetworkError.timeout {
            attempts += 1
            print("タイムアウトが発生しました。再試行中... (\(attempts)/\(maxAttempts))")
            if attempts == maxAttempts {
                throw NetworkError.timeout
            }
        }
    }
    throw NetworkError.requestFailed
}

Task {
    do {
        let data = try await fetchDataWithRetry()
        print("データ取得成功: \(data)")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

enum DetailedNetworkError: Error {
    case invalidResponse(statusCode: Int)
    case customError(message: String)
}

func handleError() async throws {
    throw DetailedNetworkError.invalidResponse(statusCode: 404)
}

Task {
    do {
        try await handleError()
    } catch DetailedNetworkError.invalidResponse(let statusCode) {
        print("無効なレスポンス: ステータスコード \(statusCode)")
    } catch DetailedNetworkError.customError(let message) {
        print("カスタムエラー: \(message)")
    } catch {
        print("不明なエラーが発生しました: \(error)")
    }
}

func logError(_ error: Error) {
    print("エラー記録: \(error)")
    // サーバーにエラーログを送信する処理など
}

Task {
    do {
        let result = try await performNetworkRequest()
        print(result)
    } catch {
        logError(error)
        print("エラーが発生しました: \(error)")
    }
}

struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

enum APIError: Error {
    case invalidURL
    case requestFailed
    case decodingFailed
}

func fetchUserData() async throws -> User {
    guard let url = URL(string: "https://api.example.com/user") else {
        throw APIError.invalidURL
    }

    let (data, _) = try await URLSession.shared.data(from: url)

    do {
        let user = try JSONDecoder().decode(User.self, from: data)
        return user
    } catch {
        throw APIError.decodingFailed
    }
}

Task {
    do {
        let user = try await fetchUserData()
        print("ユーザー名: \(user.name)")
    } catch APIError.invalidURL {
        print("無効なURLです")
    } catch APIError.requestFailed {
        print("リクエストに失敗しました")
    } catch APIError.decodingFailed {
        print("デコードに失敗しました")
    } catch {
        print("その他のエラーが発生しました: \(error)")
    }
}

@MainActor
func updateUserInterface(with user: User) {
    // ユーザーインターフェースを更新する処理
    print("ユーザーインターフェースを更新: \(user.name)")
}

Task {
    do {
        let user = try await fetchUserData()
        await updateUserInterface(with: user)
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

@MainActor
func showRetryButton() {
    print("再試行ボタンを表示")
    // 再試行ボタンをUIに表示する処理
}

@MainActor
func hideRetryButton() {
    print("再試行ボタンを非表示")
    // 再試行ボタンをUIから消す処理
}

Task {
    do {
        hideRetryButton()
        let user = try await fetchUserData()
        await updateUserInterface(with: user)
    } catch {
        showRetryButton()
        print("データ取得に失敗しました。再試行を促します。")
    }
}

func sendErrorReport(_ error: Error) async {
    // エラーレポートをサーバーに送信する処理
    print("エラーレポート送信: \(error)")
}

Task {
    do {
        let user = try await fetchUserData()
        print("ユーザー名: \(user.name)")
    } catch {
        await sendErrorReport(error)
        print("エラーをサーバーに報告しました")
    }
}