如何正确地将 3rd 方库委托转换为 RxSwift Observable

Question

我有一个案例，我正在使用第 3 方库，我想将它变成一个 Observable。适当地，库是围绕代表设计的，正如人们所期望的那样，所以我将其包装起来。该库执行异步操作，并在完成时使用结果调用它的委托。

我绝对想利用可观察对象的 cold 特性，只在有人订阅时才开始操作。我有一个有效的解决方案，我只是不知道它是否存在严重缺陷并且我缺少对 RxSwift 的一些重要理解，或者也许有更简单的方法来实现相同的目标。

public final class RxLibBridge: LibDelegate{

    let lib = Lib()
    let _source = PublishSubject<[LibResult]>()

    public init(){
        lib.delegate = self
    }

    public func asObservable() -> Observable<[LibResult]>{
        // create a cold observable to start
        // the Lib's async operation on subscribe.
        return Observable<Void>.create{
            observer in

            self.lib.startOperation()

            // emit and complete
            observer.onNext(())
            observer.onCompleted()
            return Disposables.create()
        }
        // convert the `Void` observable into an observable from the 
        // PublishSubject
        .flatMapLatest{self._source}
    }

    // the lib's completion delegate method
    public func lib(_ lib: Lib, didFinishWithResult results: [LibResult]) {
        // grab the PublishSubject, emit the result and complete
        let observer = _source.asObserver()
        observer.onNext(results)
        observer.onCompleted()
    }
}

所以我的问题是：这在 Rx 中是合适的模式吗？同样，它有效：

RxLibBridge()
    .asObservable()
    .subscribe(...)

仅仅因为它有效并不意味着我没有从根本上误解处理这种情况的正确方法。

我知道 RxSwift 中有一种方法可以处理这样的事情：

https://medium.com/@maxofeden/rxswift-migrate-delegates-to-beautiful-observables-3e606a863048#.rksg2ckpj

https://samritchie.net/2016/05/12/rxswift-delegateproxy-with-required-methods/

我试过这种方法，但看起来 API 自 2015 年以来发生了变化。也就是说，在上面的示例链接中，在扩展中添加 rx_delegate 方法时无法找到 proxyForObject .

此外，这种方法似乎有利于纯 Objective-C [UIKit/AppKit] APIs。在我尝试遵循链接示例时，我正在编辑第 3 方库的源代码以制作委托方法 optional 并将其公开给 @objc。 lib 的委托是 required，我宁愿不必分叉 lib 来进行修改。

这个 SO 答案为上面的 2 个链接提供了更新的 API：

Answer 1

所以在进一步挖掘之后，看起来这将使用所需的委托方法来解决问题，更新为 RxSwift 3.3.1。这是使用他们的 DelegateProxy 系统。

import RxSwift
import RxCocoa
import Lib


public final class RxLibDelegate: DelegateProxy, LibDelegate, DelegateProxyType{

    let _subject = PublishSubject<[LibResult]>()

    public static func currentDelegateFor(_ object: AnyObject) -> AnyObject?{
        let target = object as! Lib
        return target.delegate
    }

    public static func setCurrentDelegate(_ delegate: AnyObject?, toObject object: AnyObject) {
        let target = object as! Lib
        target.delegate = delegate as? LibDelegate
    }

    public func lib(_ lib: Lib, didFinishWithResult results: [LibResult]) {
        _subject.onNext(results)
        _subject.onCompleted()
    }
}



extension Lib{

    public var rx_delegate: DelegateProxy{
        // `proxyForDelegate` moved as compared to examples at:
        // https://samritchie.net/2016/05/12/rxswift-delegateproxy-with-required-methods/
        // https://medium.com/@maxofeden/rxswift-migrate-delegates-to-beautiful-observables-3e606a863048#.rksg2ckpj

        return RxLibDelegate.proxyForObject(self)
    }

    public var rx_libResults: Observable<[LibResult]> {
        // `proxyForDelegate` moved as compared to examples at:
        // https://samritchie.net/2016/05/12/rxswift-delegateproxy-with-required-methods/
        // https://medium.com/@maxofeden/rxswift-migrate-delegates-to-beautiful-observables-3e606a863048#.rksg2ckpj

        let proxy = RxLibDelegate.proxyForObject(self)
        return proxy._subject
    }
}

大约是 28 LOC。我原来的 "wrapper"（请参阅下面的更新版本）但我不知道它是否最好是 21 LOC； 6 个中的 1 个半打？

在我的特殊情况下，我只需要担心 1 个委托方法。如果您正在使用一些具有多个委托的功能，我认为 DelegateProxy + extension 方法会更实用，在这种情况下是更好的选择。

关于我使用 Void 可观察到的原始试验包装的东西，似乎完全可以用 flatMapLatest 改变流，如这里所证明的：按下按钮时发送连续事件：

import RxSwift
import RxCocoa


let button = submitButton.rx_controlEvent([.TouchDown])
button
.flatMapLatest { _ in
    Observable<Int64>.interval(0.1, scheduler: MainScheduler.instance)
        .takeUntil(self.submitButton.rx_controlEvent([.TouchUpInside]))
}
.subscribeNext{ x in print("BOOM \(x)") }
.addDisposableTo(disposeBag)

//prints BOOM 0 BOOM 1 BOOM 2 BOOM 3 BOOM 4 BOOM 5 for every 0.1 seconds

请注意，flatMapLatest 返回了一个新的 Observable。作者引用了RxSwift slack channel，所以我认为至少可以接受。

这是我的包装版本的更新版本，我认为它可能更干净一些：

import RxSwift


public final class RxLibBridge: LibDelegate{

    let lib = Lib()
    let _source = PublishSubject<[LibResult]>()

    public init(){
        lib.delegate = self
    }

    public func asObservable() -> Observable<[LibResult]>{
        // create a cold observable to start
        // the Lib's async operation on subscribe.
        return Observable.just(())
            .do(onNext: {
                self.lib.startOperation()
            })
            .flatMapLatest{self._source}
    }

    // the lib's completion delegate method
    public func lib(_ lib: Lib, didFinishWithResult results: [LibResult]) {
        // grab the PublishSubject, emit the result and complete
        _source.onNext(results)
        _source.onCompleted()
    }
}

如何正确地将 3rd 方库委托转换为 RxSwift Observable

How to properly convert a 3rd party library delegate into a RxSwift Observable

swift

rx-swift