我们可以定义一个 async/await function 来立即返回一个值，以及异步返回另一个值（正如您通常所期望的那样）吗？

Question

想象一个图像加载 function 并完成关闭。 假设它返回一个令牌 ID，您可以在需要时使用它来取消异步操作。

@discardableResult
func loadImage(url: URL, completion: @escaping (Result<UIImage, Error>) -> Void) -> UUID? {
    
    if let image = loadedImages[url] {
        completion(.success(image))
        return nil
    }
    
    let id = UUID()
    
    let task = URLSession.shared.dataTask(with: url) { data, response, error in
        
        defer {
            self.requests.removeValue(forKey: id)
        }
        
        if let data, let image = UIImage(data: data) {
            DispatchQueue.main.async {
                self.loadedImages[url] = image
                completion(.success(image))
            }
            return
        }
        
        if let error = error as? NSError, error.code == NSURLErrorCancelled {
            return
        }
        
        //TODO: Handle response errors
        print(response as Any)
        completion(.failure(.loadingError))
    }
    task.resume()
    
    requests[id] = task
    return id
}

func cancelRequest(id: UUID) {
    requests[id]?.cancel()
    requests.removeValue(forKey: id)
    
    print("ImageLoader: cancelling request")
}

我们如何使用 swift 并发（优雅地）完成此操作？ 它甚至可能或实用吗？

Answer 1

以元组或其他结构返回任务。

如果您不关心 ID，请执行以下操作：

try await imageTask(url: url).task.value

private var requests: [UUID: Task<UIImage, Swift.Error>] = [:]

func imageTask(url: URL) -> (id: UUID?, task: Task<UIImage, Swift.Error>) {
  switch loadedImages[url] {
  case let image?: return (id: nil, task: .init { image } )
  case nil:
    let id = UUID()
    let task = Task {
      defer { requests[id] = nil }

      guard let image = UIImage(data: try await URLSession.shared.data(from: url).0)
      else { throw Error.loadingError }

      try Task.checkCancellation()
      Task { @MainActor in loadedImages[url] = image }
      return image
    }

    requests[id] = task
    return (id: id, task: task)
  }
}

Answer 2

我没有对此做太多测试，但我相信这就是你要找的。 它允许您简单地await图像加载，但您可以从其他地方使用 URL 取消。 它还合并了对同一个 URL 的近乎同时的请求，因此您无需重新下载正在下载的内容。

actor Loader {
    private var tasks: [URL: Task<UIImage, Error>] = [:]

    func loadImage(url: URL) async throws -> UIImage {
        if let imageTask = tasks[url] {
            return try await imageTask.value
        }

        let task = Task {
            // Rather than removing here, you could skip that and this would become a
            // cache of results. Making that correct would take more work than the
            // question asks for, so I won't go into it
            defer { tasks.removeValue(forKey: url) }

            let data = try await URLSession.shared.data(from: url).0
            guard let image = UIImage(data: data) else {
                throw DecodingError.dataCorrupted(.init(codingPath: [],
                                                        debugDescription: "Invalid image"))
            }
            return image
        }
        tasks[url] = task

        return try await task.value
    }

    func cancelRequest(url: URL) {
        // Remove, and cancel if it's removed
        tasks.removeValue(forKey: url)?.cancel()
        print("ImageLoader: cancelling request")
    }
}

调用它看起来像：

let image = try await loader.loadImage(url: url)

如果请求仍在等待中，您可以取消请求：

loader.cancelRequest(url: url)

这里的一个关键教训是，多次访问task.value是很自然的。 如果任务已经完成，那么它会立即返回。

Answer 3

它甚至可能或实用吗？

对两者都是。

正如我在评论中所说，我认为您可能错过了一个事实，即任务是一个 object，您可以保留并在以后取消。 因此，如果您创建一个体系结构，在该体系结构中，您在要求任务开始时将 ID 应用于任务，则可以使用相同的 ID 在任务返回之前取消该任务。

这是一个简单的演示。 我特意将其编写为 Playground 代码（尽管我实际上是在一个 iOS 项目中开发的）。

首先，这里有一个通用的 TimeConsumer class，它包装了一个单一的耗时任务。 我们可以要求任务被创建和启动，但因为我们保留了任务，我们也可以中途取消它。 碰巧我的任务没有返回值，但它既不存在也不存在； 如果我们愿意，它可以。

class TimeConsumer {
    var current: Task<(), Error>?
    func consume(seconds: Int) async throws {
        let task = Task {
            try await Task.sleep(for: .seconds(seconds))
        }
        current = task
        _ = await task.result
    }
    func cancel() {
        current?.cancel()
    }
}

接着。 在我的 TimeConsumer 前面，我将放置一个 TaskVendor 演员。 一个 TimeConsumer 只代表一个耗时任务，但是一个 TaskVendor 有能力维护多个耗时任务，用一个标识符来标识每个任务。

actor TaskVendor {
    private var tasks = [UUID: TimeConsumer?]()
    func giveMeATokenPlease() -> UUID {
        let uuid = UUID()
        tasks[uuid] = nil
        return uuid
    }
    func beginTheTask(uuid: UUID) async throws {
        let consumer = TimeConsumer()
        tasks[uuid] = consumer
        try await consumer.consume(seconds: 10)
        tasks[uuid] = nil
    }
    func cancel(uuid: UUID) {
        tasks[uuid]??.cancel()
        tasks[uuid] = nil
    }
}

这里的所有都是它的。 观察 TaskVendor 是如何配置的：我可以做三件事，我可以请求一个令牌（实际上我的实际 TaskVendor 不需要费心这样做；但我想集中一切以实现通用性）； 我可以使用该令牌启动任务，并且可以选择取消使用该令牌的任务。

所以这是一个简单的测试工具。 开始了！

let vendor = TaskVendor()
func test() async throws {
    let uuid = await vendor.giveMeATokenPlease()
    print("start")
    Task {
        try await Task.sleep(for: .seconds(2))
        print("cancel?")
        // await vendor.cancel(uuid: uuid)
    }
    try await vendor.beginTheTask(uuid: uuid)
    print("finish")
}
Task {
    try await test()
}

您将在控制台中看到的是：

start
[two seconds later] cancel?
[eight seconds after that] finish

我们没有取消任何东西； “取消？”这个词表示我们的测试可能会取消的地方，但我们没有，因为我想向你证明这是按我们预期的方式工作的：“开始”和“完成”之间总共需要 10 秒，果然如此，我们正在完全消耗预期的时间。

现在取消注释await vendor.cancel行。 您现在将看到的是：

start
[two seconds later] cancel?
[immediately!] finish

我们做到了。 我们制作了一个可取消的任务供应商。

Answer 4

为了其他人的利益，我为这个问题提供了一个可能的答案。 我会把问题留在原地，以防有人对此有另一种看法。

我所知道的在返回异步结果之前返回令牌的“一次性”异步方法的唯一方法是添加一个 inout 参数：

func loadImage(url: URL, token: inout UUID?) async -> Result<UIImage, Error> {
    
    token = UUID()
    
    //...
}

我们可以这样称呼它：

var requestToken: UUID? = nil
let result = await imageLoader.loadImage(url: url, token: &requestToken)

但是，从 api 设计的角度来看，这种方法和@matt 的二次解决方案似乎都很挑剔。 当然，正如他所建议的，这会引出一个更大的问题：我们如何实现 swift 并发的取消（理想情况下没有太多开销）？ 事实上，使用任务和包装器对象似乎是不可避免的，但对于一个相当简单的模式来说，这似乎确实需要大量的跑腿工作。