Swiftで非同期処理をオーバーロードで実装する方法

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

func fetchData() async throws -> Data {
    let url = URL(string: "https://example.com")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

func process(data: String) {
    print("文字列を処理中: \(data)")
}

func process(data: Int) {
    print("数値を処理中: \(data)")
}

func fetchData() async throws -> String {
    let url = URL(string: "https://example.com")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(data: data, encoding: .utf8) ?? "データなし"
}

func fetchData(completion: @escaping (String?) -> Void) {
    let url = URL(string: "https://example.com")!
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let data = data {
            completion(String(data: data, encoding: .utf8))
        } else {
            completion(nil)
        }
    }.resume()
}

// URLからデータを非同期に取得するメソッド
func fetchData(from url: URL) async throws -> Data {
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// カスタムリクエストを使用してデータを非同期に取得するメソッド
func fetchData(with request: URLRequest) async throws -> Data {
    let (data, _) = try await URLSession.shared.data(for: request)
    return data
}

let url = URL(string: "https://example.com/data")!

// URLからデータを取得
Task {
    do {
        let data = try await fetchData(from: url)
        print("取得したデータ: \(data)")
    } catch {
        print("データ取得に失敗しました: \(error)")
    }
}

let request = URLRequest(url: url)

// カスタムリクエストでデータを取得
Task {
    do {
        let data = try await fetchData(with: request)
        print("カスタムリクエストのデータ: \(data)")
    } catch {
        print("カスタムリクエストでデータ取得に失敗しました: \(error)")
    }
}

// データをデコードして非同期に取得するメソッド
func fetchData<T: Decodable>(from url: URL, as type: T.Type) async throws -> T {
    let data = try await fetchData(from: url)
    let decodedData = try JSONDecoder().decode(T.self, from: data)
    return decodedData
}

let task = Task {
    for i in 1...10 {
        if Task.isCancelled {
            print("タスクがキャンセルされました")
            return
        }
        // 処理を継続
        print("処理中: \(i)")
        try await Task.sleep(nanoseconds: 1_000_000_000) // 1秒待機
    }
    print("処理が完了しました")
}

// 途中でキャンセル
Task {
    try await Task.sleep(nanoseconds: 3_000_000_000) // 3秒後にキャンセル
    task.cancel()
}

func fetchData(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://example.com")!
        let data = try await fetchData(from: url)
        print("データ取得成功: \(data)")
    } catch {
        print("データ取得に失敗しました: \(error)")
    }
}

func performLongRunningTask() async throws {
    for i in 1...10 {
        try Task.checkCancellation()  // キャンセルされていないか確認
        print("処理中: \(i)")
        try await Task.sleep(nanoseconds: 1_000_000_000) // 1秒待機
    }
}

Task {
    do {
        try await performLongRunningTask()
        print("処理が完了しました")
    } catch is CancellationError {
        print("タスクがキャンセルされました")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

func fetchData(from url: URL) async throws -> Data {
    // URLからデータを取得
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

func fetchData(with request: URLRequest) async throws -> Data {
    // リクエストからデータを取得
    let (data, _) = try await URLSession.shared.data(for: request)
    return data
}

// シンプルなURLリクエスト
Task {
    do {
        let data = try await fetchData(from: URL(string: "https://example.com")!)
        print("データ: \(data)")
    } catch {
        print("エラー: \(error)")
    }
}

// カスタムリクエストでのデータ取得
Task {
    var request = URLRequest(url: URL(string: "https://example.com")!)
    request.addValue("Bearer token", forHTTPHeaderField: "Authorization")

    do {
        let data = try await fetchData(with: request)
        print("カスタムデータ: \(data)")
    } catch {
        print("エラー: \(error)")
    }
}

// JSONデータをデコードして返すメソッド
func fetchData<T: Decodable>(from url: URL, as type: T.Type) async throws -> T {
    let data = try await fetchData(from: url)
    return try JSONDecoder().decode(T.self, from: data)
}

class APIClient {
    static let shared = APIClient()

    private init() {}  // 外部からのインスタンス化を防ぐ

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

struct NetworkService {
    func fetchData(from url: URL) async throws -> Data {
        let (data, _) = try await URLSession.shared.data(from: url)
        return data
    }
}

struct DataDecoder {
    func decode<T: Decodable>(_ data: Data, as type: T.Type) throws -> T {
        return try JSONDecoder().decode(T.self, from: data)
    }
}

let networkService = NetworkService()
let dataDecoder = DataDecoder()

Task {
    do {
        let data = try await networkService.fetchData(from: URL(string: "https://example.com")!)
        let decodedData: YourDecodableType = try dataDecoder.decode(data, as: YourDecodableType.self)
        print("デコードされたデータ: \(decodedData)")
    } catch {
        print("エラー: \(error)")
    }
}

protocol DataFetcherDelegate: AnyObject {
    func didFetchData(_ data: Data)
    func didFailWithError(_ error: Error)
}

class DataFetcher {
    weak var delegate: DataFetcherDelegate?

    func fetchData(from url: URL) async {
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            delegate?.didFetchData(data)
        } catch {
            delegate?.didFailWithError(error)
        }
    }
}

class DataManager: DataFetcherDelegate {
    func didFetchData(_ data: Data) {
        print("データを取得しました: \(data)")
    }

    func didFailWithError(_ error: Error) {
        print("エラーが発生しました: \(error)")
    }
}

let fetcher = DataFetcher()
let manager = DataManager()
fetcher.delegate = manager

Task {
    await fetcher.fetchData(from: URL(string: "https://example.com")!)
}

import Combine

func fetchData(from url: URL) -> Future<Data, Error> {
    return Future { promise in
        URLSession.shared.dataTask(with: url) { data, response, error in
            if let error = error {
                promise(.failure(error))
            } else if let data = data {
                promise(.success(data))
            }
        }.resume()
    }
}

var cancellable: AnyCancellable?

cancellable = fetchData(from: URL(string: "https://example.com")!)
    .sink(receiveCompletion: { completion in
        switch completion {
        case .failure(let error):
            print("エラー: \(error)")
        case .finished:
            print("処理が完了しました")
        }
    }, receiveValue: { data in
        print("データを取得しました: \(data)")
    })

DispatchQueue.global(qos: .background).async {
    // バックグラウンドで重い処理を実行
    let result = performHeavyTask()

    DispatchQueue.main.async {
        // メインスレッドでUIを更新
        updateUI(with: result)
    }
}

func processInParallel(urls: [URL]) async {
    await withTaskGroup(of: Data?.self) { group in
        for url in urls {
            group.addTask {
                return try? await fetchData(from: url)
            }
        }

        for await result in group {
            if let data = result {
                print("データ取得: \(data)")
            }
        }
    }
}

func readLargeFile(from url: URL) async throws {
    let fileHandle = try FileHandle(forReadingFrom: url)
    for try await line in fileHandle.bytes {
        // 一行ずつ処理する
        print("読み込み: \(line)")
    }
    try fileHandle.close()
}

let task = Task {
    try await performLongTask()
}

// キャンセル条件を満たした場合にタスクをキャンセル
task.cancel()

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

func fetchPosts() async throws -> [Post] {
    let url = URL(string: "https://jsonplaceholder.typicode.com/posts")!
    let (data, response) = try await URLSession.shared.data(from: url)

    // レスポンスの検証
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }

    // 取得したデータをデコード
    let posts = try JSONDecoder().decode([Post].self, from: data)
    return posts
}

Task {
    do {
        let posts = try await fetchPosts()
        for post in posts {
            print("Post ID: \(post.id), Title: \(post.title)")
        }
    } catch {
        print("データ取得エラー: \(error)")
    }
}

struct NewPost: Encodable {
    let title: String
    let body: String
    let userId: Int
}

func createPost(_ post: NewPost) async throws -> Post {
    let url = URL(string: "https://jsonplaceholder.typicode.com/posts")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")

    let postData = try JSONEncoder().encode(post)
    request.httpBody = postData

    let (data, response) = try await URLSession.shared.upload(for: request, from: postData)

    // レスポンスの検証
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 201 else {
        throw URLError(.badServerResponse)
    }

    // 取得したデータをデコード
    let createdPost = try JSONDecoder().decode(Post.self, from: data)
    return createdPost
}

Task {
    let newPost = NewPost(title: "新しい投稿", body: "これはテストの投稿です", userId: 1)

    do {
        let createdPost = try await createPost(newPost)
        print("作成された投稿 ID: \(createdPost.id), タイトル: \(createdPost.title)")
    } catch {
        print("POSTリクエストエラー: \(error)")
    }
}

func downloadLargeFile(from url: URL) async throws {
    let (bytes, response) = try await URLSession.shared.bytes(from: url)

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

    for try await byte in bytes {
        // 部分的にデータを処理
        print("Byte: \(byte)")
    }
}

Task {
    let url = URL(string: "https://example.com/largefile")!

    do {
        try await downloadLargeFile(from: url)
        print("ファイルダウンロード完了")
    } catch {
        print("ファイルダウンロードエラー: \(error)")
    }
}

Task {
    print("非同期処理を開始")
    do {
        let result = try await fetchData(from: URL(string: "https://example.com")!)
        print("データ取得: \(result)")
    } catch {
        print("エラー: \(error)")
    }
    print("非同期処理が終了")
}

Task {
    do {
        try Task.checkCancellation()
        print("タスクが正常に開始")
        // 長時間実行される処理
        try await performLongRunningTask()
        print("タスク完了")
    } catch is CancellationError {
        print("タスクがキャンセルされました")
    } catch {
        print("エラーが発生しました: \(error)")
    }
}

import XCTest

class APITests: XCTestCase {

    func testFetchData() async throws {
        let url = URL(string: "https://jsonplaceholder.typicode.com/posts")!
        let result = try await fetchData(from: url)

        // 取得したデータの検証
        XCTAssertFalse(result.isEmpty, "データが空でないことを確認")
    }
}

import XCTest

class NonAsyncTests: XCTestCase {

    func testAsyncDataFetching() {
        let expectation = expectation(description: "データ取得完了")

        fetchData(from: URL(string: "https://jsonplaceholder.typicode.com/posts")!) { result in
            switch result {
            case .success(let data):
                XCTAssertFalse(data.isEmpty, "データが空でないことを確認")
            case .failure(let error):
                XCTFail("データ取得に失敗: \(error)")
            }

            expectation.fulfill()  // テスト完了
        }

        waitForExpectations(timeout: 5.0, handler: nil)  // 5秒以内に完了することを期待
    }
}