Synchrone URL-Anfrage auf Swift 2

Question

Ich habe diesen Code aus here 2. synchrone Anforderung einer URL auf Swift zu tun

func send(url: String, f: (String)->()) { 
    var request = NSURLRequest(URL: NSURL(string: url)!) 
    var response: NSURLResponse? 
    var error: NSErrorPointer = nil 
    var data = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: error) 
    var reply = NSString(data: data, encoding: NSUTF8StringEncoding) 
    f(reply) 
    } 

aber die Funktion NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: error) war veraltet, und ich sehe nicht, wie ein Synchron tun können Anfragen an Swift, denn die Alternative ist asynchron. Anscheinend lehnte Apple die einzige Funktion ab, die es synchron tun kann.

Wie kann ich das tun?

Answer 1

Es gibt einen Grund für die Ablehnung - es gibt einfach keinen Nutzen für sie. Sie sollten synchrone Netzwerkanforderungen als Plage vermeiden. Es verfügt über zwei Hauptprobleme, und nur ein Vorteil (es ist einfach zu bedienen .. aber nicht so gut Asynchron?):

• die Anfrage blockiert Ihre UI wenn nicht aus anderen Thread genannt, aber wenn Sie das tun, , warum verwenden Sie den asynchronen Handler nicht sofort?
• Es gibt keine Art und Weise, wie diese Anforderung abzubrechen, außer wenn es Fehler auf eigene

Statt dessen ist nur asynchrone Anforderung verwenden:

NSURLConnection.sendAsynchronousRequest(request, queue: queue, completionHandler:{ (response: NSURLResponse!, data: NSData!, error: NSError!) -> Void in 

    // Handle incoming data like you would in synchronous request 
    var reply = NSString(data: data, encoding: NSUTF8StringEncoding) 
    f(reply) 
}) 

iOS9 Deprecation

Seit In iOS9 wird diese Methode nicht weiter unterstützt. Ich schlage vor, stattdessen NSURLSession zu verwenden:

let session = NSURLSession.sharedSession() 
session.dataTaskWithRequest(request) { (data, response, error) -> Void in 

    // Handle incoming data like you would in synchronous request 
    var reply = NSString(data: data, encoding: NSUTF8StringEncoding) 
    f(reply) 
} 

Answer 2

Wenn Sie wirklich tun wollen es synchron können Sie immer eine Semaphore verwenden:

func send(url: String, f: (String) -> Void) { 
    var request = NSURLRequest(URL: NSURL(string: url)!) 
    var error: NSErrorPointer = nil 
    var data: NSData 

    var semaphore = dispatch_semaphore_create(0) 

    try! NSURLSession.sharedSession().dataTaskWithRequest(request) { (responseData, _, _) -> Void in 
     data = responseData! //treat optionals properly 
     dispatch_semaphore_signal(semaphore) 
    }.resume() 

    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER) 

    var reply = NSString(data: data, encoding: NSUTF8StringEncoding) 
    f(reply) 
} 

EDIT: einige hackish hinzufügen! so dass der Code funktioniert, tut dies nicht in der Produktion Code

Swift 3.0+ (3.0, 3.1, 3.2, 4,0)

func send(url: String, f: (String) -> Void) { 
    guard let url = URL(string: url) else { 
     print("Error! Invalid URL!") //Do something else 
     return 
    } 

    let request = URLRequest(url: url) 
    let semaphore = DispatchSemaphore(value: 0) 

    var data: Data? = nil 

    URLSession.shared.dataTask(with: request) { (responseData, _, _) -> Void in 
     data = responseData 
     semaphore.signal() 
    }.resume() 

    semaphore.wait(timeout: .distantFuture) 

    let reply = data.flatMap { String(data: $0, encoding: .utf8) } ?? "" 
    f(reply) 
} 

Answer 3

Synchron-Anfragen sind manchmal fein auf Hintergrund-Threads. Manchmal hat man eine komplizierte, unmögliche Codebasis voller asynchroner Anfragen usw. Dann gibt es eine kleine Anfrage, die nicht als async in das aktuelle System eingeklappt werden kann. Wenn die Synchronisierung fehlschlägt, erhalten Sie keine Daten. Einfach. Es ahmt nach, wie das Dateisystem funktioniert.

Sicher, es deckt nicht alle möglichen Eventualitäten ab, aber es gibt viele Eventualitäten, die nicht asynchron abgedeckt sind.

Answer 4

Basierend auf @ fpg1503 Antwort ich eine einfache Erweiterung in Swift 3 gemacht:

extension URLSession { 

    func synchronousDataTask(with request: URLRequest) throws -> (data: Data?, response: HTTPURLResponse?) { 

     let semaphore = DispatchSemaphore(value: 0) 

     var responseData: Data? 
     var theResponse: URLResponse? 
     var theError: Error? 

     dataTask(with: request) { (data, response, error) -> Void in 

      responseData = data 
      theResponse = response 
      theError = error 

      semaphore.signal() 

     }.resume() 

     _ = semaphore.wait(timeout: .distantFuture) 

     if let error = theError { 
      throw error 
     } 

     return (data: responseData, response: theResponse as! HTTPURLResponse?) 

    } 

} 

Dazu rufen Sie einfach an:

let (data, response) = try URLSession.shared.synchronousDataTask(with: request)