Je peux en quelque sorte faire un synchrone de la requête HTTP via NSURLSession en Swift

Je peux en quelque sorte faire un synchrone de la requête HTTP via NSURLSession dans Swift?

Je peux faire une requête asynchrone via le code suivant:

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

Mais qu'en synchrone demande?

Merci d'avance.

Check this out stackoverflow.com/questions/21198404/...

InformationsquelleAutor FrozenHeart | 2014-11-06

65

Vous pouvez utiliser cette NSURLSession d'extension pour ajouter une méthode synchrone:
```
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)
    }
}
```
Mise à jour pour 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)
    }
}
```
- J'ai ajouté cette extension vers le bas de mon fichier et remplacé NSURLSession.sharedSession().dataTaskWithURL(url) avec NSURLSession.sharedSession().synchronousDataTaskWithURL(url), mais j'obtiens une erreur qu'il est un argument supplémentaire en appel. Quelle est la bonne manière d'appeler cette fonction d'extension?
- Ce que vous avez écrit est la bonne façon de l'appeler, probablement l'erreur est ailleurs. Pouvez-vous fournir plus de contexte?
- L'argument supplémentaire est le gestionnaire d'achèvement, qui n'a plus besoin d'être paramétré dans l'appel synchrone. L'appel de cette méthode se présente comme suit (en supposant que vous avez déclaré les variables): (data, response, error) = NSURLSession.sharedSession().synchronousDataTaskWithURL(url)
- Copain..où est-ce que ces valeur pour data = $0; response = $1; erreur = $2 proviennent. Veuillez expliquer!
- Ce sont les arguments de la completionHandler de rappel. Voir developer.apple.com/library/ios/documentation/Foundation/...:
- Si la demande est allé à fond et ensuite de retour au premier plan, vous faites appel api de cette façon peut provoquer http échec de chargement de la erreur parfois. Si je change la méthode de [NSURLConnection sendSynchronousRequest:XXXX ],le problème ne se produira pas.
- Quand je l'appliquer dans ma propre solution de mon gestionnaire d'achèvement n'est jamais appelé. Quand j'allume CFNetworkingDiagnostics je peux voir que l'URL de la requête terminée avec succès, mais mon gestionnaire n'est jamais exécutée. Quelqu'un l'expérience de ce bien ou avez des conseils à résoudre? Merci.
InformationsquelleAutor Nick Keets

Apple thread de discussion d'un même problème.

+ (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;  
}

Réponse par Quinn "L'Esquimau!" Apple Relations Avec Les Développeurs, Développeur
Support technique, Core OS/Matériel

Si j'ai besoin de faire de requêtes synchrones dans les deux asynchrone files d'attente avec l'aide de la même instance de la NSURLSession, le dataTasWithRequest exécutée de manière asynchrone de l'intérieur?

InformationsquelleAutor Umar Farooque

Mis à jour l'une des réponses à l'utilisation d'un URLRequest au lieu de cela, nous pouvons donc utiliser les METTRE etc au lieu de cela.

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

Je vais appeler comme ça.

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

InformationsquelleAutor Jonny

-3

Être prudent avec les requêtes synchrones, car il peut entraîner une mauvaise expérience utilisateur, mais je sais que parfois, c'est nécessaire.
Pour les requêtes synchrones utilisation NSURLConnection:

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
    }

ce n'est pas de travailler sur Swift 2 plus. Apple a apparemment décidé que nous n'avons pas besoin des requêtes synchrones.
je vous remercie pour votre commentaire. Pourriez-vous expliquer pourquoi Apple fait de même et nous dire le "droit chemin" ou donner des tutoriels utiles ou de la documentation? Merci

InformationsquelleAutor e a

Vous devez vous connecter pour publier un commentaire.