Swiftでクロージャを使った複数の非同期処理を簡単に連携させる方法

DispatchQueue.global().async {
    // 非同期で実行する処理
    print("バックグラウンドで処理を実行中")

    DispatchQueue.main.async {
        // メインスレッドでUI更新
        print("メインスレッドでUIを更新")
    }
}

func fetchData() async {
    let data = await downloadData()
    print("データを取得しました: \(data)")
}

{ (引数) -> 戻り値の型 in
    実行する処理
}

let double = { (num: Int) -> Int in
    return num * 2
}

let result = double(5)
print(result)  // 出力: 10

let double = { num in
    return num * 2
}

func fetchData(completion: @escaping (String) -> Void) {
    DispatchQueue.global().async {
        // 何らかの非同期処理（例えばネットワークからデータ取得）
        let data = "サーバーからのデータ"
        print("データ取得完了")
        DispatchQueue.main.async {
            // クロージャを使って非同期処理の完了後に実行
            completion(data)
        }
    }
}

func processData(data: String, completion: @escaping (String) -> Void) {
    DispatchQueue.global().async {
        // データを処理する非同期タスク
        let processedData = data.uppercased()
        print("データ処理完了")
        DispatchQueue.main.async {
            completion(processedData)
        }
    }
}

// クロージャを使って処理を連携させる
fetchData { data in
    processData(data: data) { processedData in
        print("最終処理完了: \(processedData)")
    }
}

func performTask(completion: @escaping () -> Void) {
    DispatchQueue.global().async {
        // タスクを実行
        DispatchQueue.main.async {
            completion()  // 非同期処理完了後にクロージャを呼び出す
        }
    }
}

let dispatchGroup = DispatchGroup()

func fetchDataFromAPI1() {
    dispatchGroup.enter()
    DispatchQueue.global().async {
        // API1の非同期処理
        print("API1のデータ取得中...")
        sleep(2) // 擬似的な遅延
        print("API1のデータ取得完了")
        dispatchGroup.leave()
    }
}

func fetchDataFromAPI2() {
    dispatchGroup.enter()
    DispatchQueue.global().async {
        // API2の非同期処理
        print("API2のデータ取得中...")
        sleep(3) // 擬似的な遅延
        print("API2のデータ取得完了")
        dispatchGroup.leave()
    }
}

fetchDataFromAPI1()
fetchDataFromAPI2()

// 全てのAPIからデータが取得されたら次の処理を実行
dispatchGroup.notify(queue: .main) {
    print("全てのAPIからデータが取得されました")
}

let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 2 // 最大2つのタスクを同時実行

operationQueue.addOperation {
    print("Task 1開始")
    sleep(2)
    print("Task 1終了")
}

operationQueue.addOperation {
    print("Task 2開始")
    sleep(2)
    print("Task 2終了")
}

operationQueue.addOperation {
    print("Task 3開始")
    sleep(2)
    print("Task 3終了")
}

func fetchDataWithRetry(attempts: Int, completion: @escaping (String?) -> Void) {
    DispatchQueue.global().async {
        let success = Bool.random() // 成功か失敗かをランダムに決定
        if success || attempts == 0 {
            DispatchQueue.main.async {
                completion(success ? "データ取得成功" : nil)
            }
        } else {
            print("リトライ: 残り\(attempts)回")
            fetchDataWithRetry(attempts: attempts - 1, completion: completion)
        }
    }
}

fetchDataWithRetry(attempts: 3) { result in
    if let data = result {
        print("最終的な結果: \(data)")
    } else {
        print("データ取得に失敗しました")
    }
}

enum DataFetchError: Error {
    case networkError
    case parsingError
}

func fetchData(completion: @escaping (Result<String, DataFetchError>) -> Void) {
    DispatchQueue.global().async {
        let success = Bool.random() // 成功か失敗かをランダムに決定

        if success {
            completion(.success("データ取得成功"))
        } else {
            completion(.failure(.networkError))
        }
    }
}

fetchData { result in
    switch result {
    case .success(let data):
        print("データを取得しました: \(data)")
    case .failure(let error):
        switch error {
        case .networkError:
            print("ネットワークエラーが発生しました")
        case .parsingError:
            print("データ解析エラーが発生しました")
        }
    }
}

func fetchData() async throws -> String {
    let success = Bool.random()

    if success {
        return "データ取得成功"
    } else {
        throw DataFetchError.networkError
    }
}

Task {
    do {
        let data = try await fetchData()
        print("データを取得しました: \(data)")
    } catch DataFetchError.networkError {
        print("ネットワークエラーが発生しました")
    } catch {
        print("予期せぬエラーが発生しました: \(error)")
    }
}

func fetchDataWithTimeout(timeout: TimeInterval, completion: @escaping (Result<String, DataFetchError>) -> Void) {
    let queue = DispatchQueue.global()
    let deadline = DispatchTime.now() + timeout

    queue.async {
        let success = Bool.random() // 成功か失敗かをランダムに決定

        if success {
            completion(.success("データ取得成功"))
        } else {
            completion(.failure(.networkError))
        }
    }

    queue.asyncAfter(deadline: deadline) {
        completion(.failure(.networkError))
    }
}

fetchDataWithTimeout(timeout: 2.0) { result in
    switch result {
    case .success(let data):
        print("データを取得しました: \(data)")
    case .failure(let error):
        print("タイムアウトまたはネットワークエラー: \(error)")
    }
}

import Combine

// APIからデータを取得するPublisherを作成
func fetchDataFromAPI() -> Future<String, Error> {
    return Future { promise in
        DispatchQueue.global().async {
            let success = Bool.random()
            if success {
                promise(.success("APIからのデータ取得成功"))
            } else {
                promise(.failure(NSError(domain: "APIエラー", code: 1, userInfo: nil)))
            }
        }
    }
}

// Combineを使ってデータを取得し、処理を行う
let cancellable = fetchDataFromAPI()
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("すべての処理が完了しました")
        case .failure(let error):
            print("エラーが発生しました: \(error)")
        }
    }, receiveValue: { data in
        print("取得したデータ: \(data)")
    })

let cancellable = fetchDataFromAPI()
    .map { data in
        return data.uppercased() // データを大文字に変換
    }
    .flatMap { processedData in
        return fetchDataFromAPI() // 次のAPIリクエスト
    }
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("すべての処理が完了しました")
        case .failure(let error):
            print("エラーが発生しました: \(error)")
        }
    }, receiveValue: { data in
        print("最終データ: \(data)")
    })

let cancellable = fetchDataFromAPI()
    .retry(2) // 最大2回リトライ
    .catch { error in
        return Just("デフォルトデータ") // エラー発生時に代替データを返す
    }
    .sink(receiveCompletion: { completion in
        print("処理完了")
    }, receiveValue: { data in
        print("取得したデータ: \(data)")
    })

let cancellable = fetchDataFromAPI()
    .receive(on: DispatchQueue.main) // メインスレッドで受け取る
    .sink(receiveCompletion: { completion in
        print("処理完了")
    }, receiveValue: { data in
        print("メインスレッドでデータを表示: \(data)")
    })

import Combine
import Foundation

// APIからユーザー情報を取得するPublisher
func fetchUser() -> Future<User, Error> {
    return Future { promise in
        DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
            let user = User(id: 1, name: "John Doe")
            promise(.success(user))
        }
    }
}

// APIから投稿情報を取得するPublisher
func fetchPosts(for userId: Int) -> Future<[Post], Error> {
    return Future { promise in
        DispatchQueue.global().asyncAfter(deadline: .now() + 3) {
            let posts = [Post(id: 1, title: "Swiftの非同期処理"), Post(id: 2, title: "Combineフレームワークの活用")]
            promise(.success(posts))
        }
    }
}

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

struct Post {
    let id: Int
    let title: String
}

// Combineでデータ取得とUI更新を連携
let cancellable = fetchUser()
    .flatMap { user in
        fetchPosts(for: user.id)
            .map { posts in
                (user, posts) // ユーザー情報と投稿情報をまとめて返す
            }
    }
    .receive(on: DispatchQueue.main) // UI更新はメインスレッドで行う
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("すべてのデータ取得が完了しました")
        case .failure(let error):
            print("エラーが発生しました: \(error)")
        }
    }, receiveValue: { user, posts in
        print("ユーザー名: \(user.name)")
        print("投稿:")
        posts.forEach { post in
            print("- \(post.title)")
        }
        // ここでUI更新処理を行う
    })

let cancellableWithErrorHandling = fetchUser()
    .flatMap { user in
        fetchPosts(for: user.id)
            .map { posts in
                (user, posts)
            }
    }
    .retry(1) // 1回リトライを試みる
    .catch { error in
        Just((User(id: 0, name: "ゲストユーザー"), [])) // エラー時に代替データを返す
    }
    .receive(on: DispatchQueue.main)
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("処理が完了しました")
        case .failure(let error):
            print("エラー: \(error)")
        }
    }, receiveValue: { user, posts in
        if user.id == 0 {
            print("ゲストユーザーとして表示")
        } else {
            print("ユーザー名: \(user.name)")
            print("投稿:")
            posts.forEach { post in
                print("- \(post.title)")
            }
        }
    })

DispatchQueue.global().async {
    // 重い処理
    let imageData = downloadLargeImage()

    DispatchQueue.main.async {
        // メインスレッドでUI更新
        imageView.image = UIImage(data: imageData)
    }
}

let cancellable = fetchDataFromAPI()
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("完了しました")
        case .failure(let error):
            print("エラーが発生しました: \(error)")
        }
    }, receiveValue: { data in
        print("取得したデータ: \(data)")
    })

// 処理をキャンセルしたい場合
cancellable.cancel()

let imageCache = NSCache<NSString, UIImage>()

func fetchImage(url: String, completion: @escaping (UIImage?) -> Void) {
    if let cachedImage = imageCache.object(forKey: url as NSString) {
        completion(cachedImage)
        return
    }

    DispatchQueue.global().async {
        guard let imageURL = URL(string: url),
              let imageData = try? Data(contentsOf: imageURL),
              let image = UIImage(data: imageData) else {
            completion(nil)
            return
        }

        imageCache.setObject(image, forKey: url as NSString)
        DispatchQueue.main.async {
            completion(image)
        }
    }
}

let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 2 // 同時実行数を制限

operationQueue.addOperation {
    print("タスク1を実行中")
}

operationQueue.addOperation {
    print("タスク2を実行中")
}

operationQueue.addOperation {
    print("タスク3を実行中")
}

func performTask() {
    DispatchQueue.global().async { [weak self] in
        // 非同期処理
        guard let self = self else { return }
        self.processData()
    }
}

import XCTest

class AsyncTests: XCTestCase {

    func testFetchData() {
        let expectation = self.expectation(description: "データ取得の完了を待つ")

        fetchData { result in
            XCTAssertNotNil(result, "データがnilではないことを確認")
            expectation.fulfill() // テストの完了を通知
        }

        wait(for: [expectation], timeout: 5.0) // 5秒以内に完了することを期待
    }

    func fetchData(completion: @escaping (String?) -> Void) {
        DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
            completion("データ取得成功")
        }
    }
}

func testMultipleAsyncTasks() {
    let expectation1 = expectation(description: "タスク1の完了を待つ")
    let expectation2 = expectation(description: "タスク2の完了を待つ")

    fetchData { result in
        XCTAssertNotNil(result, "タスク1のデータがnilではないことを確認")
        expectation1.fulfill()
    }

    fetchAnotherData { result in
        XCTAssertNotNil(result, "タスク2のデータがnilではないことを確認")
        expectation2.fulfill()
    }

    wait(for: [expectation1, expectation2], timeout: 5.0)
}

func fetchAnotherData(completion: @escaping (String?) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 3) {
        completion("別のデータ取得成功")
    }
}

import XCTest
import Combine

class CombineAsyncTests: XCTestCase {

    var cancellables = Set<AnyCancellable>()

    func testCombineFetchData() {
        let expectation = self.expectation(description: "Combineでのデータ取得完了を待つ")

        fetchDataPublisher()
            .sink(receiveCompletion: { completion in
                switch completion {
                case .finished:
                    expectation.fulfill() // 処理完了
                case .failure(let error):
                    XCTFail("エラーが発生しました: \(error)")
                }
            }, receiveValue: { data in
                XCTAssertEqual(data, "データ取得成功")
            })
            .store(in: &cancellables)

        wait(for: [expectation], timeout: 5.0)
    }

    func fetchDataPublisher() -> AnyPublisher<String, Error> {
        return Future { promise in
            DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
                promise(.success("データ取得成功"))
            }
        }
        .eraseToAnyPublisher()
    }
}

func testFetchDataWithError() {
    let expectation = self.expectation(description: "エラー処理を待つ")

    fetchDataWithError { result in
        switch result {
        case .success(let data):
            XCTFail("成功すべきでない: \(data)")
        case .failure(let error):
            XCTAssertEqual(error, DataFetchError.networkError)
            expectation.fulfill()
        }
    }

    wait(for: [expectation], timeout: 5.0)
}

func fetchDataWithError(completion: @escaping (Result<String, DataFetchError>) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
        completion(.failure(.networkError))
    }
}

enum DataFetchError: Error {
    case networkError
}

func fetchDataFromServer(completion: @escaping (String) -> Void)

func fetchDataFromServer(completion: @escaping (String) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
        let result = "データ取得成功"
        completion(result) // 非同期処理の完了を通知
    }
}

// 実行して確認
fetchDataFromServer { result in
    print(result) // 期待する出力: "データ取得成功"
}

ユーザー情報取得成功
投稿取得成功

func fetchUserData(completion: @escaping (String) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
        completion("ユーザー情報取得成功")
    }
}

func fetchUserPosts(completion: @escaping (String) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
        completion("投稿取得成功")
    }
}

// 連続する非同期処理の実装
fetchUserData { userData in
    print(userData) // "ユーザー情報取得成功"を出力

    fetchUserPosts { userPosts in
        print(userPosts) // "投稿取得成功"を出力
    }
}

func fetchDataWithError(completion: @escaping (Result<String, Error>) -> Void)

enum DataError: Error {
    case fetchFailed
}

func fetchDataWithError(completion: @escaping (Result<String, Error>) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
        let success = Bool.random()
        if success {
            completion(.success("データ取得成功"))
        } else {
            completion(.failure(DataError.fetchFailed))
        }
    }
}

// 実行して確認
fetchDataWithError { result in
    switch result {
    case .success(let data):
        print(data) // データ取得成功
    case .failure(let error):
        print("エラー: \(error)") // データ取得失敗
    }
}