Ios 函数在NSURLSession之前完成-dataTaskWithRequest已完成

我在ViewDidLoad（）下调用了以下方法。我知道session.dataTaskWithRequest会自动在后台线程中运行。同样，ViewDidLoad（）中遵循此方法的代码不会等待此过程完成并开始执行

是否有任何方法可以确保在执行其他方法之前完成后台线程

    func getCoordinatesFromServer() {
        let request = NSMutableURLRequest(URL: NSURL(string: constants.urlName.loadData)!)
        request.HTTPMethod = "POST"
        request.addValue("multipart/form-data", forHTTPHeaderField: "Accept")
        request.setValue("keep-Alive", forHTTPHeaderField: "Connection")
        request.HTTPBody = (constants.requestTag.getCoordinates).data

        let session = NSURLSession.sharedSession()
        let task = session.dataTaskWithRequest(request, completionHandler: {(data, response ,error ) in
            if let response = response {
                let httpResponse = response as! NSHTTPURLResponse

                print("response code = \(httpResponse.statusCode)")
                if (httpResponse.statusCode == 200) {
                    dispatch_async(dispatch_get_main_queue(), {
                        let decodedData = NSData(base64EncodedData: data!, options: NSDataBase64DecodingOptions([]))
                        let jsonText = NSString(data: decodedData!, encoding: NSASCIIStringEncoding) as! String
                        do {
                        let json = try NSJSONSerialization.JSONObjectWithData(jsonText.data, options: NSJSONReadingOptions.init(rawValue: 0))
                        self.parseJsonData(json["Datalist"] as! NSArray)
                        } catch {
                        print("Error:\n \(error)")
                        }
                    })
                }
            }
        })
        task.resume()
    }

---

关于，

datataskhithrequest

是一个关联调用，它有

completionHandler

块。因此，您在其中编写的所有代码都将在数据任务完成后执行：

let request = NSURLRequest(URL: NSURL(string: "http://google.com")!)
let task = NSURLSession.sharedSession().dataTaskWithRequest(request, completionHandler: {(data, response ,error ) in
    print("3") // executed after data task is finished
    print("4") // executed after data task is finished
})
task.resume()
print("1")
print("2")

---

如果我理解你的问题，你可以用这种方法解决这个问题 例如：

class func ConnectedToNetwork(completionHandler: ((Status: Bool) -> Void))
    {
    let url = NSURL(string: "http://google.com")
    let request = NSMutableURLRequest(URL: url!)
    request.HTTPMethod =  "HEAD"
    request.timeoutInterval = 0.2
       let task = NSURLSession.sharedSession().dataTaskWithURL(url!)    {(data,response, error) in
            let httpResponse = response as! NSHTTPURLResponse
                if httpResponse.statusCode == 200
                {   completionHandler(Status: true)
                    return
                }
        }
        task.resume()
    }

然后，你可以用这个

Checks.ConnectedToNetwork({ Status in dispatch_async(dispatch_get_main_queue())
        {
            if Status == true
            {
                //do what you want
             }
});

---

这根本不是最好的，更好的解决方案是运行同步版本的f（），而不是这个“解决方法”：-）

感谢您花时间回答这个问题。我知道完成处理程序在数据任务完成后被调用。我的问题是

如果必须在ViewDidLoad（）方法中使用此dataTaskWithRequest

，我应该如何确保在执行其他方法之前执行完成处理程序。将这些方法移动到

ViewDidLoad

部分这似乎不是一个好的解决方案。我不确定您是否理解我的问题。该链接的标题是NSURLConnection，但它与您需要的技术相同。PK20询问：“如何确保在执行其他方法之前执行完成处理程序”。我不明白，为什么有人抱怨我的答案。。。我不是说，这种“wokraround”是程序员的最佳实践。我只是试图解释，如何等待进一步的程序执行，直到所有异步代码完成。我的答案怎么了？顺便说一下，这种技术有时可能非常有用。。。

import Foundation

// some aync function with completition handler, i MUST USE AS IT IS
func f(completitionHandler: ()->()) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0)) { () -> Void in
        print("running concurrently")
        sleep(1)
        print("finished")
        completitionHandler()
    }
}

// some function running on main queue
func foo() {
    // create dispatch group
    let group = dispatch_group_create()
    let myCompletitionHandler: ()->() = {
        dispatch_group_leave(group)
    }
    let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0)
    dispatch_group_async(group, queue) { () -> Void in
        dispatch_group_enter(group)
        f(myCompletitionHandler)
    }
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER)
}

foo()
print("foo finished")