Posso in qualche modo eseguire una richiesta HTTP sincrona tramite NSURLSession in Swift

Question

Posso in qualche modo eseguire una richiesta HTTP sincrona tramite NSURLSession in Swift?

posso fare una richiesta asincrona tramite il seguente codice:

if let url = NSURL(string: "https://2ch.hk/b/threads.json") { 
      let task = NSURLSession.sharedSession().dataTaskWithURL(url) { 
       (data, response, error) in 

       var jsonError: NSError? 
       let jsonDict = NSJSONSerialization.JSONObjectWithData(data, options: nil, error: &jsonError) as [String: AnyObject] 
       if jsonError != nil { 
        return 
       } 

       // ... 
      } 
      task.resume() 
     } 

Ma per quanto riguarda richiesta sincrona?

Grazie in anticipo.

Answer 1

Fare attenzione alle richieste sincrone perché può causare un'esperienza utente negativa ma a volte so che è necessaria. Per richieste sincrone usano NSURLConnection: "The Eskimo"

func synchronousRequest() -> NSDictionary { 

     //creating the request 
     let url: NSURL! = NSURL(string: "exampledomain/...") 
     var request = NSMutableURLRequest(URL: url) 
     request.HTTPMethod = "GET" 
     request.addValue("application/json", forHTTPHeaderField: "Content-Type") 


     var error: NSError? 

     var response: NSURLResponse? 

     let urlData = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: &error) 

     error = nil 
     let resultDictionary: NSDictionary = NSJSONSerialization.JSONObjectWithData(urlData!, options: NSJSONReadingOptions.MutableContainers, error: &error) as! NSDictionary 

     return resultDictionary 
    } 

Answer 2

Apple thread discussing the same issue.

+ (NSData *)sendSynchronousRequest:(NSURLRequest *)request 
    returningResponse:(__autoreleasing NSURLResponse **)responsePtr 
    error:(__autoreleasing NSError **)errorPtr { 
    dispatch_semaphore_t sem; 
    __block NSData *  result; 

    result = nil; 

    sem = dispatch_semaphore_create(0); 

    [[[NSURLSession sharedSession] dataTaskWithRequest:request 
     completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) { 
     if (errorPtr != NULL) { 
      *errorPtr = error; 
     } 
     if (responsePtr != NULL) { 
      *responsePtr = response; 
     } 
     if (error == nil) { 
      result = data; 
     } 
     dispatch_semaphore_signal(sem); 
    }] resume]; 

    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER); 

    return result; 
} 

Risposta da Quinn Di Apple Developer Relations, sviluppatori supporto tecnico, Core OS/hardware

Answer 3

È possibile utilizzare questa estensione NSURLSession per aggiungere un metodo sincrono:

extension NSURLSession { 
    func synchronousDataTaskWithURL(url: NSURL) -> (NSData?, NSURLResponse?, NSError?) { 
     var data: NSData?, response: NSURLResponse?, error: NSError? 

     let semaphore = dispatch_semaphore_create(0) 

     dataTaskWithURL(url) { 
      data = $0; response = $1; error = $2 
      dispatch_semaphore_signal(semaphore) 
     }.resume() 

     dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) 

     return (data, response, error) 
    } 
} 

Aggiornamento per Swift 3:

extension URLSession { 
    func synchronousDataTask(with url: URL) -> (Data?, URLResponse?, Error?) { 
     var data: Data? 
     var response: URLResponse? 
     var error: Error? 

     let semaphore = DispatchSemaphore(value: 0) 

     let dataTask = self.dataTask(with: url) { 
      data = $0 
      response = $1 
      error = $2 

      semaphore.signal() 
     } 
     dataTask.resume() 

     _ = semaphore.wait(timeout: .distantFuture) 

     return (data, response, error) 
    } 
} 

Answer 4

Aggiornamento di una delle risposte per utilizzare invece una richiesta URLRequest, in modo che possiamo utilizzare PUT, ecc.

extension URLSession { 
    func synchronousDataTask(urlrequest: URLRequest) -> (data: Data?, response: URLResponse?, error: Error?) { 
     var data: Data? 
     var response: URLResponse? 
     var error: Error? 

     let semaphore = DispatchSemaphore(value: 0) 

     let dataTask = self.dataTask(with: urlrequest) { 
      data = $0 
      response = $1 
      error = $2 

      semaphore.signal() 
     } 
     dataTask.resume() 

     _ = semaphore.wait(timeout: .distantFuture) 

     return (data, response, error) 
    } 
} 

Sto chiamando così.

var request = URLRequest(url: url1) 
request.httpBody = body 
request.httpMethod = "PUT" 
let (_, _, error) = URLSession.shared.synchronousDataTask(urlrequest: request) 
if let error = error { 
    print("Synchronous task ended with error: \(error)") 
} 
else { 
    print("Synchronous task ended without errors.") 
}