swift - 如何在 Eureka SelectableSection 上进行适当的响应式(Reactive)扩展

Question

这是我向 StackOverflow 社区提出的第一个问题，如果我做错了什么，请原谅。

<强>1。我想要实现的目标
基本上，我想围绕 Eureka 的 SelectableSection 制作一个自定义响应式(Reactive)包装器类以便在更改时观察所选行的值。我想从 onSelectSelectableRow 获取这些数据每次选择一行时都会调用闭包。

<强>2。我为此尝试过的事情
实际上，我已经得到了这个工作，但它不是自定义包装器的通用使用，这里是工作的示例，但仅当我指定行及其值类型时，例如 ListCheckRow<Int> .

extension SelectableSection: ReactiveCompatible {}
extension Reactive where Base : SelectableSection<ListCheckRow<Int>> {
  var selectedValue: Observable<Base.SelectableRow.Cell.Value?> {
    return Observable.create { observer in
      self.base.onSelectSelectableRow = {cell, row in
        observer.onNext(row.value)
      }
      return Disposables.create {
        observer.onCompleted()
      }
    }
  }
}

这工作正常，正如我预期的那样，但是当涉及到更通用的内容(例如下一个代码示例)时，我收到一条错误消息:“无法分配给属性:'base'是一个'let'常量”

extension SelectableSection: ReactiveCompatible {}
extension Reactive where Base : SelectableSectionType {
  var selectedValue: Observable<Base.SelectableRow.Cell.Value?> {
    return Observable.create { observer in
      self.base.onSelectSelectableRow = {cell, row in // Error: Cannot assign to property: 'base' is a 'let' constant
        observer.onNext(row.value)
      }
      return Disposables.create {
        observer.onCompleted()
      }
    }
  }
}

任何帮助将不胜感激，谢谢。 🙏

Answer 1

这里的根本问题是 SelectableSectionType 是一个不限于类类型的协议(protocol)，而 Reactive 假设 Base 是一个类(否则不会被可观察的创建所修改。)

我认为你可以做的最通用的事情是这样的:

extension Reactive {
    func selectedValue<Row, T>() -> Observable<T?> where Base: SelectableSection<Row>, Row: SelectableRowType, T == Row.Cell.Value  {
        Observable.create { [base] observer in
            base.onSelectSelectableRow = { cell, row in
                observer.onNext(row.value) // this is problematic. See below.
            }
            return Disposables.create {
                observer.onCompleted() // this is wrong. See below.
            }
        }
    }
}

上述最大的问题是，如果您多次订阅生成的 Observable 或使用此计算属性创建多个 Observable，则除了最后一次订阅之外的所有订阅都将默默失败。解决此问题的简单方法是始终记住分享任何结果，但这很容易出错。

解决这个问题的方法是将一个Subject与每个SelectableSection关联起来，但是你不能修改这个类，那么我们该怎么办？

解决方案如下:

extension Reactive {
    func selectedValue<Row, T>() -> Observable<T?> where Base: SelectableSection<Row>, Row: SelectableRowType, T == Row.Cell.Value  {
        Observable.create { [base] observer in
            if let block = selectableSections.first(where: { $0.section === base }) {
                let subject = block.subject as! PublishSubject<T?>
                return Disposables.create(
                    block.disposable.retain(),
                    subject.subscribe(observer)
                )
            }
            else {
                let subject = PublishSubject<T?>()
                let block = SelectableSectionBlock(
                    section: base,
                    subject: subject,
                    disposable: RefCountDisposable(disposable: Disposables.create {
                        selectableSections.removeAll(where: { $0.section === base })
                    })
                )
                base.onSelectSelectableRow = { cell, row in
                    subject.onNext(row.value)
                }
                selectableSections.append(block)
                return Disposables.create(
                    block.disposable,
                    subject.subscribe(observer)
                )
            }
        }
    }
}

private struct SelectableSectionBlock {
    let section: Section
    let subject: Any
    let disposable: RefCountDisposable
}

private var selectableSections = [SelectableSectionBlock]()

selectableSections 数组存储每个 SelectableSection 的主题和 RefCountDisposable。

每当创建或订阅 Observable 时...

• 如果这是第一次使用此部分，它将创建一个主题，并且 RefCountDisposable 分配 onSelectSelectableRow 以将下一个事件发送到主题并将主题存储在数组中。
• 否则它将找到与本部分相关的主题和一次性元素并保留该一次性元素。

一旦它从上面获得了主题和一次性，它将为新的观察者订阅该主题并返回一个新的一次性，该新的一次性将删除该订阅并在时间到来时减少引用计数。

是的，这比简单的赋值情况要复杂得多，但这是正确的做法。

至于在一次性闭包内调用onCompleted()。当闭包被调用时，观察者已经发出了 onCompleted/onError 事件，或者观察者已经停止监听 observable。所以这个事件永远不会被看到。