从 Swift 函数中的异步调用返回数据
Posted
技术标签:
【中文标题】从 Swift 函数中的异步调用返回数据【英文标题】：Returning data from async call in Swift function 【发布时间】：2014-08-08 12:28:59 【问题描述】：我在我的 Swift 项目中创建了一个实用程序类，用于处理所有 REST 请求和响应。我已经构建了一个简单的 REST API，因此我可以测试我的代码。我创建了一个需要返回 NSArray 的类方法，但是因为 API 调用是异步的，所以我需要从异步调用中的方法返回。问题是异步返回无效。 如果我在 Node 中执行此操作，我会使用 JS 承诺，但我无法找到适用于 Swift 的解决方案。
import Foundation
class Bookshop
class func getGenres() -> NSArray
println("Hello inside getGenres")
let urlPath = "http://creative.coventry.ac.uk/~bookshop/v1.1/index.php/genre/list"
println(urlPath)
let url: NSURL = NSURL(string: urlPath)
let session = NSURLSession.sharedSession()
var resultsArray:NSArray!
let task = session.dataTaskWithURL(url, completionHandler: data, response, error -> Void in
println("Task completed")
if(error)
println(error.localizedDescription)
var err: NSError?
var options:NSJSONReadingOptions = NSJSONReadingOptions.MutableContainers
var jsonResult = NSJSONSerialization.JSONObjectWithData(data, options: options, error: &err) as NSDictionary
if(err != nil)
println("JSON Error \(err!.localizedDescription)")
//NSLog("jsonResults %@", jsonResult)
let results: NSArray = jsonResult["genres"] as NSArray
NSLog("jsonResults %@", results)
resultsArray = results
return resultsArray // error [anyObject] is not a subType of 'Void'
)
task.resume()
//return "Hello World!"
// I want to return the NSArray...
【问题讨论】：
这个错误在 Stack Overflow 上很常见，我写了一系列博客文章来处理它，从programmingios.net/what-asynchronous-means开始 【参考方案1】：你可以传递回调，并在异步调用中调用回调
类似：
class func getGenres(completionHandler: (genres: NSArray) -> ())
...
let task = session.dataTaskWithURL(url)
data, response, error in
...
resultsArray = results
completionHandler(genres: resultsArray)
...
task.resume()
然后调用这个方法：
override func viewDidLoad()
Bookshop.getGenres
genres in
println("View Controller: \(genres)")
【讨论】：
谢谢。我的最后一个问题是如何从我的视图控制器调用这个类方法。代码目前是这样的：override func viewDidLoad() super.viewDidLoad() var genres = Bookshop.getGenres() // Missing argument for parameter #1 in call //var genres:NSArray //Bookshop.getGenres(genres) NSLog("View Controller: %@", genres) 【参考方案2】：
Swiftz 已经提供了 Future，它是 Promise 的基本构建块。 Future 是一个不会失败的 Promise（这里所有的术语都是基于 Scala 的解释，where a Promise is a Monad）。
https://github.com/maxpow4h/swiftz/blob/master/swiftz/Future.swift
希望最终会扩展为完整的 Scala 风格的 Promise（我可能会在某个时候自己编写它；我相信其他 PR 会受到欢迎；如果 Future 已经到位，这并不难）。
在您的特定情况下，我可能会创建一个Result<[Book]>（基于Alexandros Salazar's version of Result）。那么您的方法签名将是：
class func fetchGenres() -> Future<Result<[Book]>>
注意事项
我不建议在 Swift 中为函数添加get 前缀。它将破坏与 ObjC 的某些类型的互操作性。
我建议在将结果作为Future 返回之前一直解析到Book 对象。这个系统有几种失败的方式，如果你在将它们包装成Future之前检查所有这些东西会更方便。对于您的 Swift 代码的其余部分而言，使用 [Book] 比提交 NSArray 要好得多。
【讨论】：
Swiftz 不再支持Future。但是看看github.com/mxcl/PromiseKit，它与 Swiftz 配合得很好！
我花了几秒钟才意识到你不是写 Swift 而是写了 Swiftz
听起来“Swiftz”是 Swift 的第三方函数库。由于您的答案似乎基于该库，因此您应该明确说明。 （例如，“有一个名为 'Swiftz' 的第三方库支持像 Futures 这样的功能结构，如果你想实现 Promises，应该作为一个很好的起点。”）否则你的读者会想知道你为什么拼错了“斯威夫特”。
请注意github.com/maxpow4h/swiftz/blob/master/swiftz/Future.swift 不再工作了。
@Rob get 前缀表示 ObjC 中的按引用返回（例如在 -[UIColor getRed:green:blue:alpha:] 中）。当我写这篇文章时，我担心进口商会利用这一事实（例如自动返回一个元组）。事实证明他们没有。当我写这篇文章时，我可能还忘记了 KVC 支持访问器的“get”前缀（这是我学过并忘记了好几次的东西）。所以同意了；我没有遇到任何领先的get 破坏事情的情况。这只会误导那些知道 ObjC “get”含义的人。【参考方案3】：
在 Swift 5.5（iOS 15、macOS 12）中引入，我们现在将使用 async-await 模式：
func fetchGenres() async throws -> [Genre]
…
let (data, _) = try await URLSession.shared.dataTask(for: request)
return try JSONDecoder().decode([Genre].self, from: data)
我们可以这样称呼它：
let genres = try await fetchGenres()
async-await 语法比我在下面的原始答案中概述的传统完成处理程序模式更加简洁和自然。
有关详细信息，请参阅Meet async/await in Swift。
历史模式是使用完成处理程序闭包。
例如，我们经常使用Result：
func fetchGenres(completion: @escaping (Result<[Genre], Error>) -> Void)
...
URLSession.shared.dataTask(with: request) data, _, error in
if let error = error
DispatchQueue.main.async
completion(.failure(error))
return
// parse response here
let results = ...
DispatchQueue.main.async
completion(.success(results))
.resume()
你会这样称呼它：
fetchGenres results in
switch results
case .failure(let error):
print(error.localizedDescription)
case .success(let genres):
// use `genres` here, e.g. update model and UI
// but don’t try to use `genres` here, as the above runs asynchronously
注意，上面我将完成处理程序分派回主队列以简化模型和 UI 更新。一些开发者不同意这种做法，要么使用任何队列URLSession，要么使用他们自己的队列（要求调用者自己手动同步结果）。
但这在这里并不重要。关键问题是使用完成处理程序来指定异步请求完成时要运行的代码块。
注意，上面我不再使用NSArray（我们不再使用those bridged Objective-C types）。我假设我们有一个Genre 类型并且我们大概使用JSONDecoder，而不是JSONSerialization 来解码它。但是这个问题没有足够的关于底层 JSON 的信息来详细介绍这里，所以我省略了它以避免混淆核心问题，即使用闭包作为完成处理程序。
【讨论】：
您也可以在 Swift 4 及更低版本中使用Result，但您必须自己声明枚举。我多年来一直在使用这种模式。
是的，当然，我也是。但它看起来只是随着 Swift 5 的发布而被 Apple 接受。他们只是迟到了。【参考方案4】：
Swift 4.0
对于异步请求响应，您可以使用完成处理程序。见下文，我已经使用完成句柄范例修改了解决方案。
func getGenres(_ completion: @escaping (NSArray) -> ())
let urlPath = "http://creative.coventry.ac.uk/~bookshop/v1.1/index.php/genre/list"
print(urlPath)
guard let url = URL(string: urlPath) else return
let task = URLSession.shared.dataTask(with: url) (data, response, error) in
guard let data = data else return
do
if let jsonResult = try JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions.mutableContainers) as? NSDictionary
let results = jsonResult["genres"] as! NSArray
print(results)
completion(results)
catch
//Catch Error here...
task.resume()
你可以像下面这样调用这个函数：
getGenres (array) in
// Do operation with array
【讨论】：
【参考方案5】：@Alexey Globchastyy 的回答的 Swift 3 版本：
class func getGenres(completionHandler: @escaping (genres: NSArray) -> ())
...
let task = session.dataTask(with:url)
data, response, error in
...
resultsArray = results
completionHandler(genres: resultsArray)
...
task.resume()
【讨论】：
【参考方案6】：我希望你不会仍然坚持这一点，但简短的回答是你不能在 Swift 中做到这一点。
另一种方法是返回一个回调，该回调将在数据准备就绪后立即提供您需要的数据。
【讨论】：
他也可以迅速做出承诺。但是苹果目前推荐的 aproceh 是使用callback 和 closures，就像你指出的那样，或者像旧的可可 API 一样使用 delegation
你对 Promises 的看法是正确的。但是 Swift 并没有为此提供原生 API，所以他必须使用 PromiseKit 或其他替代方案。【参考方案7】：
有 3 种创建回调函数的方法，即： 1.完成处理程序 2. 通知 3. 代表
完成处理程序 当源可用时执行并返回内部块集，处理程序将等待响应到来，以便之后更新UI。
通知 整个应用程序都会触发大量信息，Listner 可以检索并使用该信息。通过项目获取信息的异步方式。
代表 调用委托时会触发一组方法，必须通过方法本身提供Source
【讨论】：
【参考方案8】：Swift 5.5，基于异步/等待的解决方案
原始发帖人提供的原始测试 URL 不再起作用，所以我不得不稍作改动。这个解决方案基于我发现的一个笑话 API。该 API 返回一个笑话，但我将其作为字符串数组 ([String]) 返回，以使其与原始帖子尽可能一致。
class Bookshop
class func getGenres() async -> [String]
print("Hello inside getGenres")
let urlPath = "https://geek-jokes.sameerkumar.website/api?format=json"
print(urlPath)
let url = URL(string: urlPath)!
let session = URLSession.shared
typealias Continuation = CheckedContinuation<[String], Never>
let genres = await withCheckedContinuation (continuation: Continuation) in
let task = session.dataTask(with: url) data, response, error in
print("Task completed")
var result: [String] = []
defer
continuation.resume(returning: result)
if let error = error
print(error.localizedDescription)
return
guard let data = data else
return
do
let jsonResult = try JSONSerialization.jsonObject(with: data, options: [.mutableContainers])
print("jsonResult is \(jsonResult)")
if let joke = (jsonResult as? [String: String])?["joke"]
result = [joke]
catch
print("JSON Error \(error.localizedDescription)")
print("data was \(String(describing: String(data: data, encoding: .utf8)))")
return
task.resume()
return genres
async
let final = await Bookshop.getGenres()
print("Final is \(final)")
withCheckedContinuation 是您使 Swift async 函数实际在单独的任务/线程中运行的方式。
【讨论】：
【参考方案9】：斯威夫特 5.5：
TL;DR：Swift 5.5 尚未发布（在撰写本文时）。要使用 swift 5.5，请从 here 下载 swift 工具链开发快照并添加编译器标志 -Xfrontend -enable-experimental-concurrency。阅读更多here
这可以通过async/await 功能轻松实现。
为此，您应该将您的函数标记为async，然后在withUnsafeThrowingContinuation 块内执行操作，如下所示。
class Bookshop
class func getGenres() async throws -> NSArray
print("Hello inside getGenres")
let urlPath = "http://creative.coventry.ac.uk/~bookshop/v1.1/index.php/genre/list"
print(urlPath)
let url = URL(string: urlPath)!
let session = URLSession.shared
return try await withUnsafeThrowingContinuation continuation in
let task = session.dataTask(with: url, completionHandler: data, response, error -> Void in
print("Task completed")
if(error != nil)
print(error!.localizedDescription)
continuation.resume(throwing: error!)
return
do
let jsonResult = try JSONSerialization.jsonObject(with: data!, options: .mutableContainers) as? [String: Any]
let results: NSArray = jsonResult!["genres"] as! NSArray
continuation.resume(returning: results)
catch
continuation.resume(throwing: error)
)
task.resume()
你可以像这样调用这个函数
@asyncHandler
func check()
do
let genres = try await Bookshop.getGenres()
print("Result: \(genres)")
catch
print("Error: \(error)")
请记住，在调用Bookshop.getGenres 方法时，调用者方法应为async 或标记为@asyncHandler
【讨论】：
【参考方案10】：self.urlSession.dataTask(with: request, completionHandler: (data, response, error) in
self.endNetworkActivity()
var responseError: Error? = error
// handle http response status
if let httpResponse = response as? HTTPURLResponse
if httpResponse.statusCode > 299 , httpResponse.statusCode != 422
responseError = NSError.errorForHTTPStatus(httpResponse.statusCode)
var apiResponse: Response
if let _ = responseError
apiResponse = Response(request, response as? HTTPURLResponse, responseError!)
self.logError(apiResponse.error!, request: request)
// Handle if access token is invalid
if let nsError: NSError = responseError as NSError? , nsError.code == 401
DispatchQueue.main.async
apiResponse = Response(request, response as? HTTPURLResponse, data!)
let message = apiResponse.message()
// Unautorized access
// User logout
return
else if let nsError: NSError = responseError as NSError? , nsError.code == 503
DispatchQueue.main.async
apiResponse = Response(request, response as? HTTPURLResponse, data!)
let message = apiResponse.message()
// Down time
// Server is currently down due to some maintenance
return
else
apiResponse = Response(request, response as? HTTPURLResponse, data!)
self.logResponse(data!, forRequest: request)
self.removeRequestedURL(request.url!)
DispatchQueue.main.async(execute: () -> Void in
completionHandler(apiResponse)
)
).resume()
【讨论】：
【参考方案11】：swift中实现回调主要有3种方式
闭包/完成处理程序
代表
通知
观察者也可用于在异步任务完成后获得通知。
【讨论】：
【参考方案12】：每个优秀的 API 管理器都希望满足一些非常通用的要求： 将实现一个面向协议的 API 客户端。
APIClient 初始接口
protocol APIClient
func send(_ request: APIRequest,
completion: @escaping (APIResponse?, Error?) -> Void)
protocol APIRequest: Encodable
var resourceName: String get
protocol APIResponse: Decodable
现在请检查完整的api结构
// ******* This is API Call Class *****
public typealias ResultCallback<Value> = (Result<Value, Error>) -> Void
/// Implementation of a generic-based API client
public class APIClient
private let baseEndpointUrl = URL(string: "irl")!
private let session = URLSession(configuration: .default)
public init()
/// Sends a request to servers, calling the completion method when finished
public func send<T: APIRequest>(_ request: T, completion: @escaping ResultCallback<DataContainer<T.Response>>)
let endpoint = self.endpoint(for: request)
let task = session.dataTask(with: URLRequest(url: endpoint)) data, response, error in
if let data = data
do
// Decode the top level response, and look up the decoded response to see
// if it's a success or a failure
let apiResponse = try JSONDecoder().decode(APIResponse<T.Response>.self, from: data)
if let dataContainer = apiResponse.data
completion(.success(dataContainer))
else if let message = apiResponse.message
completion(.failure(APIError.server(message: message)))
else
completion(.failure(APIError.decoding))
catch
completion(.failure(error))
else if let error = error
completion(.failure(error))
task.resume()
/// Encodes a URL based on the given request
/// Everything needed for a public request to api servers is encoded directly in this URL
private func endpoint<T: APIRequest>(for request: T) -> URL
guard let baseUrl = URL(string: request.resourceName, relativeTo: baseEndpointUrl) else
fatalError("Bad resourceName: \(request.resourceName)")
var components = URLComponents(url: baseUrl, resolvingAgainstBaseURL: true)!
// Common query items needed for all api requests
let timestamp = "\(Date().timeIntervalSince1970)"
let hash = "\(timestamp)"
let commonQueryItems = [
URLQueryItem(name: "ts", value: timestamp),
URLQueryItem(name: "hash", value: hash),
URLQueryItem(name: "apikey", value: "")
]
// Custom query items needed for this specific request
let customQueryItems: [URLQueryItem]
do
customQueryItems = try URLQueryItemEncoder.encode(request)
catch
fatalError("Wrong parameters: \(error)")
components.queryItems = commonQueryItems + customQueryItems
// Construct the final URL with all the previous data
return components.url!
// ****** API Request Encodable Protocol *****
public protocol APIRequest: Encodable
/// Response (will be wrapped with a DataContainer)
associatedtype Response: Decodable
/// Endpoint for this request (the last part of the URL)
var resourceName: String get
// ****** This Results type Data Container Struct ******
public struct DataContainer<Results: Decodable>: Decodable
public let offset: Int
public let limit: Int
public let total: Int
public let count: Int
public let results: Results
// ***** API Errro Enum ****
public enum APIError: Error
case encoding
case decoding
case server(message: String)
// ****** API Response Struct ******
public struct APIResponse<Response: Decodable>: Decodable
/// Whether it was ok or not
public let status: String?
/// Message that usually gives more information about some error
public let message: String?
/// Requested data
public let data: DataContainer<Response>?
// ***** URL Query Encoder OR JSON Encoder *****
enum URLQueryItemEncoder
static func encode<T: Encodable>(_ encodable: T) throws -> [URLQueryItem]
let parametersData = try JSONEncoder().encode(encodable)
let parameters = try JSONDecoder().decode([String: HTTPParam].self, from: parametersData)
return parameters.map URLQueryItem(name: $0, value: $1.description)
// ****** HTTP Pamater Conversion Enum *****
enum HTTPParam: CustomStringConvertible, Decodable
case string(String)
case bool(Bool)
case int(Int)
case double(Double)
init(from decoder: Decoder) throws
let container = try decoder.singleValueContainer()
if let string = try? container.decode(String.self)
self = .string(string)
else if let bool = try? container.decode(Bool.self)
self = .bool(bool)
else if let int = try? container.decode(Int.self)
self = .int(int)
else if let double = try? container.decode(Double.self)
self = .double(double)
else
throw APIError.decoding
var description: String
switch self
case .string(let string):
return string
case .bool(let bool):
return String(describing: bool)
case .int(let int):
return String(describing: int)
case .double(let double):
return String(describing: double)
/// **** This is your API Request Endpoint Method in Struct *****
public struct GetCharacters: APIRequest
public typealias Response = [MyCharacter]
public var resourceName: String
return "characters"
// Parameters
public let name: String?
public let nameStartsWith: String?
public let limit: Int?
public let offset: Int?
// Note that nil parameters will not be used
public init(name: String? = nil,
nameStartsWith: String? = nil,
limit: Int? = nil,
offset: Int? = nil)
self.name = name
self.nameStartsWith = nameStartsWith
self.limit = limit
self.offset = offset
// *** This is Model for Above Api endpoint method ****
public struct MyCharacter: Decodable
public let id: Int
public let name: String?
public let description: String?
// ***** These below line you used to call any api call in your controller or view model ****
func viewDidLoad()
let apiClient = APIClient()
// A simple request with no parameters
apiClient.send(GetCharacters()) response in
response.map dataContainer in
print(dataContainer.results)
【讨论】：
【参考方案13】：这是一个可能有用的小用例：-
func testUrlSession(urlStr:String, completionHandler: @escaping ((String) -> Void))
let url = URL(string: urlStr)!
let task = URLSession.shared.dataTask(with: url)(data, response, error) in
guard let data = data else return
if let strContent = String(data: data, encoding: .utf8)
completionHandler(strContent)
task.resume()
调用函数时：-
testUrlSession(urlStr: "YOUR-URL") (value) in
print("Your string value ::- \(value)")
【讨论】：
以上是关于从 Swift 函数中的异步调用返回数据的主要内容，如果未能解决你的问题，请参考以下文章