Swift 可观测系统中的无限阻塞轮询

我使用的库允许我轮询事件（阻塞），直到没有更多的事件（在这种情况下，它返回

nil

）

我很想这样实现可观察的：

private func createObservable() -> Observable<MyEvents> {
    return Observable.create { observer in
        let myPollingObject = PollingObject()

        while let event = try myPollingObject.poll() {
            observer.onNext(event)
        }

        return Disposables.create()
    }
}

private func createObservable（）->Observable{
返回可观察的。在中创建{observer
让myPollingObject=PollingObject（）
当let event=尝试myPollingObject.poll（）时{
observer.onNext（事件）
}
返回一次性物品。创建（）
}
}

当不再有事件时，

while

循环结束（并且

poll（）

返回

nil

）

但是，

while

循环意味着我从不

返回一次性用品。create（）

，这是一个问题

---

有没有更被动的方法来实现这一点？我真的不想把

放在线程中，

循环…

你必须把循环放在调度队列中。您还应该正确处理错误，并在错误完成时通知订阅者。还有一些取消的方法会很好

func createObservable() -> Observable<MyEvents> {
    return Observable.create { observer in
        let myPollingObject = PollingObject()
        var canceled = false
        DispatchQueue.init(label: "poller").async {
            do {
                while let event = try myPollingObject.poll(), !canceled {
                    observer.onNext(event)
                }
                if !canceled {
                    observer.onCompleted()
                }
            }
            catch {
                observer.onError(error)
            }
        }
        return Disposables.create { canceled = true }
    }
}

func createObservable（）->Observable{
返回可观察的。在中创建{observer
让myPollingObject=PollingObject（）
var=false
DispatchQueue.init（标签：“轮询器”）.async{
做{
当let event=尝试myPollingObject.poll（）时，已取消{
observer.onNext（事件）
}
如果！取消{
observer.onCompleted（）
}
}
抓住{
observer.onError（错误）
}
}
返回一次性用品。创建{cancelled=true}
}
}

您必须将循环包装在调度队列中。您还应该正确处理错误，并在错误完成时通知订阅者。还有一些取消的方法会很好

func createObservable() -> Observable<MyEvents> {
    return Observable.create { observer in
        let myPollingObject = PollingObject()
        var canceled = false
        DispatchQueue.init(label: "poller").async {
            do {
                while let event = try myPollingObject.poll(), !canceled {
                    observer.onNext(event)
                }
                if !canceled {
                    observer.onCompleted()
                }
            }
            catch {
                observer.onError(error)
            }
        }
        return Disposables.create { canceled = true }
    }
}

func createObservable（）->Observable{
返回可观察的。在中创建{observer
让myPollingObject=PollingObject（）
var=false
DispatchQueue.init（标签：“轮询器”）.async{
做{
当let event=尝试myPollingObject.poll（）时，已取消{
observer.onNext（事件）
}
如果！取消{
observer.onCompleted（）
}
}
抓住{
observer.onError（错误）
}
}
返回一次性用品。创建{cancelled=true}
}
}