swift - 使用链式函数的 Swift 完成处理程序

Question

我将一些函数链接在一起，但我不知道如何在所有函数运行完毕后调用带有返回值的完成处理程序。

class AirQualityProvider {
    var aBlock: ((Int?) -> Void)?

    func getAirQuality(completion: @escaping (Int?) -> Void) {
        aBlock = completion
        callAPI()
    }

    private func callAPI() {
        let data = Data()
        parseDataForAQI(data: data)
    }

    private func parseDataForAQI(data: Data) {

        for d in data {
            dosomeMath(d)
        }
    }


    private func dosomeMath(data: Int) {

        // HERE IS WHERE I WANT IT TO SUM UP ALL THE NUMBERS
        THEN ONLY RETURN ONE VALUE using a completion handler.
        Currently, it returns the average as it is being generated.
    }

在亚历山大的帮助下几乎可以正常工作了。亚历山大提供的代码运行完美，令人惊叹。问题是，当我在 alamofire 中运行 taskrunner 时，它返回空。在 alamofire 之外它照常工作。我需要在 alamofire 内运行它。

func A(json : JSON){
    for (key,subJson) in json{
        if subJson["free"].doubleValue > 0.0 {
            func B(asset: subJson["asset"].stringValue, json: subJson)
        }
    }

    print(taskRunner.getResults())
}


func B(asset : String, json : JSON){

        //OUTSIDE ALAMOFIRE WORKS
            self.taskRunner.execute{
            return 100
        }

    Alamofire.request(url).responseJSON { response in

       //INSIDE ALAMOFIRE DOESN'T WORK. Returns []
            self.taskRunner.execute{
            return 100
        }

    }

}

Answer 1

我将使用调度队列来同步结果的聚合(通过同步 Array.append(_:) 调用以及随后的数组读取)。这是一个简单的例子:

import Dispatch
import Foundation

class ParallelTaskRunner<Result> {
    private var results = [Result]()
    private let group = DispatchGroup()
    private let resultAggregatorQueue = DispatchQueue(label: "Result Aggregator")

    func execute(_ closure: (@escaping (Result) -> Void) -> Void) {
        group.enter() // Register that a new task is in-flight
        closure { result in
            self.resultAggregatorQueue.sync { // Synchronize access to the array
                self.results.append(result) // Record the result
            }
            self.group.leave() // This task is done
        }
    }

    func getResults() -> [Result] {
        group.wait() // Make sure all in-flight tasks are done
        return resultAggregatorQueue.sync { return results }
    }
}




let taskQueue = DispatchQueue(label: "Task Queue", attributes: .concurrent)
let taskRunner = ParallelTaskRunner<Int>()
for i in 0...100 {
    taskRunner.execute { completionHandler in 
        taskQueue.async { // Simulated async computation
            let randomTime = 3.0
            print("Sleeping for \(randomTime)")
            Thread.sleep(forTimeInterval: randomTime) // Simulates intesnive computation
            let result = i // Simulate a result
            completionHandler(result)
        }
    }
}
print(taskRunner.getResults()) // Oh look, all the results are here! :D