स्विफ्ट

Question

का उपयोग कर iOS पर async संचालन के साथ synchronically दो कार्यों को चलाने के लिए कैसे की सुविधा देता है async नेटवर्क संचालन

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 

} 

async नेटवर्क संचालन के साथ एक और विधि के साथ इस परिदृश्य

एक विधि का प्रस्ताव

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 
} 

एक तरीका जिसमें मैं उन तरीकों को ए और बी कहूंगा, कुछ संचालन करने के लिए

func displayResult 
{ 
    1) let a = asyncMethodA() 
    2) let b = asyncMethodB() 
    3) println(a + b) //some chaotic stuff might happen :(
} 

तो सवाल यह है कि मैं इसे (2) चलाने के लिए (1) चलाने के लिए इंतजार कर सकता है, और (3) (2) और इतने पर (वह 1,2 और 3 रन सिंक्रोनिज्ड) की प्रतीक्षा करता है?

(मुझे पता है कि एक ही जवाब श्रृंखला asyncMethodA और displayResult asyncMethodB में करने के लिए है, लेकिन अगर वहाँ किसी अन्य विधि है जानना चाहता हूँ)

धन्यवाद !.

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

नीचे दिए गए के साथ, आप एक ही समय में async विधियों को लॉन्च कर सकते हैं और जो भी अंतिम समाप्त होता है उसके बाद भारी भारोत्तोलन कर सकते हैं।

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 
} 

asyncMethodB की हिम्मत ऊपर कोड के लिए methodBFinished = true; doStuff()

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

Answer 3

धन्यवाद Yimin होगा।

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) 
}