Swift：异步回调

Question

如何快速进行异步回调？我正在为我的应用程序编写一个小框架，因为它应该在 iOS 和 OS X 两者上运行。所以我将非设备特定的主要代码放入这个框架中，该框架还处理对我的在线 api 的请求。显然，我还希望应用程序的 GUI 以及我的 ViewControllers 在 api 请求完成后立即做出反应。在 Objective-C 中，我通过将包含必须在 id 变量中调用的函数的视图和函数本身保存在选择器变量中来做到这一点。然后我使用以下代码调用了该函数：

SEL selector = callbackMethod;
((void (*)(id, SEL))[callbackViewController methodForSelector:selector])(callbackViewController, selector);

我怎样才能快速完成这项工作？或者有更好的方法吗？

非常感谢您的帮助！

Answer 1

我在以下要点中分享了我用于此场景的模式：https://gist.github.com/szehnder/84b0bd6f45a7f3f99306

基本上，我创建了一个设置 AFNetworking 客户端的单例 DataProvider.swift。然后视图控制器调用该 DataProvider 上的方法，每个方法都由我定义为名为 ServiceResponse 的类型别名的闭包终止。此闭包返回字典或错误。

它允许您非常干净地（imo）从 VC 调用异步数据操作，并非常清楚地指示您希望在该异步响应返回时执行什么。

DataProvider.swift

typealias ServiceResponse = (NSDictionary?, NSError?) -> Void

class DataProvider: NSObject {

    var client:AFHTTPRequestOperationManager?
    let LOGIN_URL = "/api/v1/login"

    class var sharedInstance:DataProvider {
        struct Singleton {
            static let instance = DataProvider()
        }
        return Singleton.instance
    }

    func setupClientWithBaseURLString(urlString:String) {
        client = AFHTTPRequestOperationManager(baseURL: NSURL.URLWithString(urlString))
        client!.operationQueue = NSOperationQueue.mainQueue()
        client!.responseSerializer = AFJSONResponseSerializer()
        client!.requestSerializer = AFJSONRequestSerializer()
    }

    func loginWithEmailPassword(email:String, password:String, onCompletion: ServiceResponse) -> Void {
        self.client!.POST(LOGIN_URL, parameters: ["email":email, "password":password] , success: {(operation:AFHTTPRequestOperation!, responseObject:AnyObject!) -> Void in

            self.setupClientWithBaseURLString("http://somebaseurl.com")

            let responseDict = responseObject as NSDictionary
                // Note: This is where you would serialize the nsdictionary in the responseObject into one of your own model classes (or core data classes)
                onCompletion(responseDict, nil)
            }, failure: {(operation: AFHTTPRequestOperation!, error:NSError!) -> Void  in
                onCompletion(nil, error)
            })
    }
}

MyViewController.swift

import UIKit

class MyViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }

    override func viewWillAppear(animated: Bool)  {
        super.viewWillAppear(animated)
        DataProvider.sharedInstance.loginWithEmailPassword(email:"some@email.com", password:"somepassword") { (responseObject:NSDictionary?, error:NSError?) in

            if (error) {
                println("Error logging you in!")
            } else {
                println("Do something in the view controller in response to successful login!")
            }
        }
    }  
}

Answer 2

我想建议使用块或闭包回调而不是使用 NSThread 和选择器。

例如，在我的 API 中，我有以下方法：

斯威夫特：

您将在下面找到更新的实现。

func getUsers(completion: (result: NSArray?, error: NSError?)->())
{
    var session = NSURLSession.sharedSession()
    var task = session.dataTaskWithRequest(request){
     (data, response, error) -> Void in
       if error != nil {
         completion(nil, error)
       } else {
         var result:NSArray = data to NSArray;
         completion(result, nil)
       }
    }
    task.resume()
}

目标-C：

...
typedef void (^CBSuccessBlock)(id result);
typedef void (^CBFailureBlock)(NSError *error);
...

- (void)usersWithSucces:(CBSuccessBlock)success failure:(CBFailureBlock)failure
{
    NSURLSession *session = [NSURLSession sharedSession];
    [[session dataTaskWithURL:[NSURL URLWithString:url]
            completionHandler:^(NSData *data,
                                NSURLResponse *response,
                                NSError *error) {

                NSArray *users = //convert data to array

                if(error)
                    failure(error);
                else
                    success(users);
            }] resume];
}

然后，只需从视图控制器调用 api：

Objc:
[api usersWithSucces:^(id result)
{
   //Success callback
} failure:^(NSError *error)
{
   //Failure callback
}];

Swift:
api.getUsers({(result: AnyObject?, error: NSError?) -> Int in
    // callback here
})

更新：

同时，我看到问题和答案仍然有用且感兴趣。好吧，这是使用通用枚举作为结果对象的 swift 实现的更新版本：

//Generic enum that represents the result
enum AsyncResult<T>
{
    case Success(T)
    case Failure(NSError?)
}


class CustomUserObject
{

}

func getUsers(completion: (AsyncResult<[CustomUserObject]>)->())
{
    let request = NSURLRequest()
    let session = NSURLSession.sharedSession()
    let task = session.dataTaskWithRequest(request){
        (data, response, error) -> Void in
        if let error = error
        {
            completion(AsyncResult.Failure(error))
        } else {
            let result: [CustomUserObject] = []//deserialization json data into array of [CustomUserObject]
            completion(AsyncResult.Success(result))
        }
    }
    task.resume()
}

//Usage:

getUsers { (result) in
    switch result
    {
    case .Success(let users):
        /* work with users*/
        break
    case .Failure(let error):
        /* present an error */
        break
    }
}

Answer 3

我刚刚做了这个小例子： Swift: Async callback block pattern example

基本上有ClassA：

//ClassA it's the owner of the callback, he will trigger the callback when it's the time
class ClassA {
    //The property of that will be associated to the ClassB callback
    var callbackBlock : ((error : NSError?, message : String?, adress : String? ) -> Void)?

    init() {
        //Do Your staff
    }

    //Define your function with the clousure as a parameter
    func yourFunctionWithCallback(#functionCallbackParameter : (error : NSError?,message : String?, adress : String?) -> ()) {
        //Set the calback with the calback in the function parameter
        self.callbackBlock = functionCallbackParameter
    }

    //Later On..
    func callbackTrigger() {
        self.callbackBlock?(error: nil,message: "Hello callback", adress: "I don't know")

    }
}

和B类：

//ClassB it's the callback reciver the callback
class ClassB {
    @IBAction func testCallbackFunction(sender: UIButton) {
        let classA = ClassA()
        classA.yourFunctionWithCallback { (error, message, adress) -> () in
            //Do your stuff
        }
    }
}

ClassA： 它拥有一个属性，即回调块。 ClassB 将通过调用 yourFunctionWithCallback 函数来设置此属性。稍后ClassA就准备好了，会在callbackTrigger函数里面调用callBackBlock来触发回调。

ClassB：会调用ClassA方法设置回调块，等待块被触发。

Answer 4

NSThread 可以帮助你吗？ ：

NSThread.detachNewThreadSelector(<#selector: Selector#>, toTarget: <#AnyObject?#>, withObject: <#AnyObject?#>)