这不是您整个问题的真正答案——只是关于如何开始使用 Combine 的部分。我将演示如何使用 Combine 框架链接两个异步操作：
print("start")
Future<Bool,Error> { promise in
delay(3) {
promise(.success(true))
}
}
.handleEvents(receiveOutput: {_ in print("finished 1")})
.flatMap {_ in
Future<Bool,Error> { promise in
delay(3) {
promise(.success(true))
}
}
}
.handleEvents(receiveOutput: {_ in print("finished 2")})
.sink(receiveCompletion: {_ in}, receiveValue: {_ in print("done")})
.store(in:&self.storage) // storage is a persistent Set<AnyCancellable>
首先，你的持久化问题的答案是：最终订阅者必须持久化，而做到这一点的方法是使用.store 方法。通常，您将拥有 Set<AnyCancellable> 作为属性，就像这里一样，您只需调用 .store 作为管道中的最后一件事，将您的订阅者放入其中。
接下来，在这个管道中，我使用.handleEvents 只是为了在管道移动时给自己一些打印输出。这些只是诊断，在实际实现中不存在。所有print 声明都是纯粹的，所以我们可以谈论这里发生的事情。
那么会发生什么？
start
finished 1 // 3 seconds later
finished 2 // 3 seconds later
done
所以你可以看到我们已经链接了两个异步操作，每个操作需要 3 秒。
我们是怎么做到的？我们从 Future 开始，它必须在完成时调用传入的 promise 方法，并使用 Result 作为完成处理程序。之后，我们使用.flatMap 产生另一个 Future 并投入运行，再次做同样的事情。
所以结果并不漂亮（如 PromiseKit），但它是一个异步操作链。
在使用 Combine 之前，我们可能已经使用某种 Operation / OperationQueue 依赖项来完成此操作，这样可以正常工作，但 PromiseKit 的直接可读性会更少。
更真实一点
说了这么多，这里有一个更现实的重写：
var storage = Set<AnyCancellable>()
func async1(_ promise:@escaping (Result<Bool,Error>) -> Void) {
delay(3) {
print("async1")
promise(.success(true))
}
}
func async2(_ promise:@escaping (Result<Bool,Error>) -> Void) {
delay(3) {
print("async2")
promise(.success(true))
}
}
override func viewDidLoad() {
print("start")
Future<Bool,Error> { promise in
self.async1(promise)
}
.flatMap {_ in
Future<Bool,Error> { promise in
self.async2(promise)
}
}
.sink(receiveCompletion: {_ in}, receiveValue: {_ in print("done")})
.store(in:&self.storage) // storage is a persistent Set<AnyCancellable>
}
如您所见，我们未来发布者的想法只需传递promise 回调即可；他们实际上不必是打电话给他们的人。因此可以在任何地方调用promise 回调，直到那时我们才会继续。
因此，您可以很容易地看到如何用真正的异步操作替换人工的delay，该操作以某种方式持有这个promise 回调并且可以在它完成时调用它。另外我的承诺结果类型纯粹是人为的，但你可以再次看到它们如何用于在管道中传达有意义的东西。当我说promise(.success(true)) 时，这会导致true 弹出管道的末端；我们在这里忽略了这一点，但它可能是某种彻头彻尾的有用价值，甚至可能是下一个未来。
（还请注意，我们可以在链中的任何位置插入.receive(on: DispatchQueue.main)，以确保紧随其后的内容在主线程上启动。）
稍微整洁
我还想到，通过将 Future 发布者移到常量中，我们可以使语法更整洁，也许更接近 PromiseKit 的可爱简单链。但是，如果您这样做，您可能应该将它们包装在延迟发布者中，以防止过早评估。比如：
var storage = Set<AnyCancellable>()
func async1(_ promise:@escaping (Result<Bool,Error>) -> Void) {
delay(3) {
print("async1")
promise(.success(true))
}
}
func async2(_ promise:@escaping (Result<Bool,Error>) -> Void) {
delay(3) {
print("async2")
promise(.success(true))
}
}
override func viewDidLoad() {
print("start")
let f1 = Deferred{Future<Bool,Error> { promise in
self.async1(promise)
}}
let f2 = Deferred{Future<Bool,Error> { promise in
self.async2(promise)
}}
// this is now extremely neat-looking
f1.flatMap {_ in f2 }
.receive(on: DispatchQueue.main)
.sink(receiveCompletion: {_ in}, receiveValue: {_ in print("done")})
.store(in:&self.storage) // storage is a persistent Set<AnyCancellable>
}