Come eseguire sincronicamente due funzioni con le operazioni asincrone su iOS che utilizzano Swift

Question

consente di proporre questo scenario

un metodo con le operazioni di rete asincrone

func asyncMethodA() -> String? 
{ 
    result : String? 
    Alamofire.manager.request(.POST, "https://www.apiweb.com/apimethod", parameters: parameters, encoding:.JSON) 
      .response { (request, response, rawdata, error) in 
       if (response?.statusCode == 200) 
       { 
        //DO SOME HEAVY LIFTING 
       } 
     } 
     return result //string 

} 

un altro metodo con le operazioni di rete asincrono

func asyncMethodB() -> String? 
{ 
    result : String? 
    Alamofire.manager.request(.POST, "https://www.yetanotherapiweb.com/apimethod", parameters: parameters, encoding:.JSON) 
      .response { (request, response, rawdata, error) in 
       if (response?.statusCode == 200) 
       { 
        //DO SOME HEAVY LIFTING 

       } 
     } 
     return result //string 
} 

un metodo in cui chiamerò quei metodi A e B, per fare alcune operazioni

quindi la domanda è come potrei fare che (2) aspetti (1) di correre, e (3) attenda per (2) e così via (che 1,2 e 3 corrano sincronizzati)?

(So che una risposta è quella di catena asyncMethodA e displayResult in asyncMethodB, ma voglio sapere se c'è qualche altro metodo)

grazie !.

Answer 1

func anAsyncMethod(resultHandler: (result: AnyObject) -> Void) { 
    ...   
} 

func anotherAsyncMethod(resultHandler: (result: AnyObject) -> Void) { 
    ... 
} 

let operationQueue = NSOperationQueue() 

func performWithCompletionHandler(completion: (AnyObject?, AnyObject?) -> Void) { 
     var resultOfOperation1: AnyObject? 
     var resultOfOperation2: AnyObject? 

     let operation1 = NSBlockOperation { 
       let dispatchGroup = dispatch_group_create() 
       dispatch_group_enter(dispatchGroup) 
       self.anAsyncMethod { 
         result in 
         resultOfOperation1 = result 
         dispatch_group_leave(dispatchGroup) 
       } 
       // wait until anAsyncMethod is completed 
       dispatch_group_wait(dispatchGroup, DISPATCH_TIME_FOREVER) 
     } 

     let operation2 = NSBlockOperation { 
       let dispatchGroup = dispatch_group_create() 
       dispatch_group_enter(dispatchGroup) 
       self.anotherAsyncMethod { 
         result in 
         resultOfOperation2 = result 
         dispatch_group_leave(dispatchGroup) 
       } 
       // wait until anotherAsyncMethod is completed 
       dispatch_group_wait(dispatchGroup, DISPATCH_TIME_FOREVER) 
     } 

     let completionOperation = NSBlockOperation { 
       // send all results to completion callback 
       completion(resultOfOperation1, resultOfOperation2) 
     } 

     // configuring interoperation dependencies 
     operation2.addDependency(operation1) 
     completionOperation.addDependency(operation2) 

     operationQueue.addOperations([operation1, operation2, completionOperation], waitUntilFinished: false) 
} 

Answer 2

Con quanto riportato di seguito, è possibile avviare contemporaneamente entrambi i metodi asincroni e eseguire il sollevamento pesante dopo il termine ultimo.

var methodAFinished = false 
var methodBFinished = false 

func asyncMethodA() -> String? 
{ 
    Alamofire.manager.request(.POST, "https://www.apiweb.com/apimethod", parameters: parameters, encoding:.JSON) 
     .response { (request, response, rawdata, error) in 
      if (response?.statusCode == 200) { 
       methodAFinished = true 
       doStuff() 
      } 
     } 
    return result //string 
} 

viscere del asyncMethodB sarebbero methodBFinished = true; doStuff()

func doStuff() { 
    if methodAFinished && methodBFinished { 
     // do crazy stuff 
    } 
} 

Answer 3

Grazie Yimin per il codice precedente. Ho aggiornato alla più recente sintassi Swift quindi basta inviare per essere utile:

func anAsyncMethod(resultHandler: (_ result: AnyObject) -> Void) { 
    ... 
} 

func anotherAsyncMethod(resultHandler: (_ result: AnyObject) -> Void) { 
    ... 
} 

func performWithCompletionHandler(completion: @escaping (AnyObject?, AnyObject?) -> Void) { 

    let operationQueue = OperationQueue() 

    var resultOfOperation1: AnyObject? 
    var resultOfOperation2: AnyObject? 

    let operation1 = BlockOperation { 
     let dispatchGroup = DispatchGroup() 
     dispatchGroup.enter() 
     self.anAsyncMethod { 
      result in 
      resultOfOperation1 = result 
      dispatchGroup.leave() 
     } 
     // wait until anAsyncMethod is completed 
     dispatchGroup.wait(timeout: DispatchTime.distantFuture) 
    } 

    let operation2 = BlockOperation { 
     let dispatchGroup = DispatchGroup() 
     dispatchGroup.enter() 
     self.anotherAsyncMethod { 
      result in 
      resultOfOperation2 = result 
      dispatchGroup.leave() 
     } 
     // wait until anotherAsyncMethod is completed 
     dispatchGroup.wait(timeout: DispatchTime.distantFuture) 
    } 

    let completionOperation = BlockOperation { 
     // send all results to completion callback 
     completion(resultOfOperation1, resultOfOperation2) 
    } 

    // configuring interoperation dependencies 
    operation2.addDependency(operation1) 
    completionOperation.addDependency(operation2) 

    operationQueue.addOperations([operation1, operation2, completionOperation], waitUntilFinished: false) 
}