ios – 使用“拳击”式的多重绑定和处理

概述这是一个非常具体和长期的问题,但我不够聪明,不能自己解决这个问题. 我对来自raywenderlich.com的this YouTube-video非常感兴趣,它使用“拳击”方法来观察一个值. 他们的Box看起来像这样： class Box<T> { typealias Listener = T -> Void var listener: Listener? var va 这是一个非常具体和长期的问题,但我不够聪明,不能自己解决这个问题.

我对来自raywenderlich.com的this YouTube-video非常感兴趣,它使用“拳击”方法来观察一个值.

他们的Box看起来像这样：

class Box<T> {    typealias Listener = T -> VoID    var Listener: Listener?    var value: T {        dIDSet {            Listener?(value)        }    init(_ value: T) {        self.value = value    }    func bind(Listener: Listener?) {        self.Listener = Listener        Listener?(value)    }}

很明显,每个“盒子”只允许一个听众.

let bindable:Box<String> = Box("Some text")bindable.bind { (text) in    //This will only be called once (from initial setup)}bindable.bind { (text) in    // - because this Listener has replaced it. This one will be called when value changes.}

只要设置了这样的绑定,就会释放先前的绑定,因为Box用新的侦听器替换了侦听器.

我需要能够从不同的地方观察到相同的价值.我像这样重写了Box：

class Box<T> {    typealias Listener = (T) -> VoID    var Listeners:[Listener?] = []    var value:T{        dIDSet{            Listeners.forEach({
func freshBind(Listener:Listener?){    self.Listeners.removeAll()    self.bind(Listener)}
?(value)})        }    }    init(_ value:T){        self.value = value    }    func bind(Listener:Listener?){        self.Listeners.append(Listener)        Listener?(value)    }}

然而 – 这也给我带来了麻烦,显然..有些地方我希望新绑定删除旧绑定.例如,如果我从可重用的UItableVIEwCell中观察对象中的值,则在滚动时它将被绑定多次.我现在需要一种受控制的方式来处理特定的绑定.

我试图通过将此函数添加到Box来解决此问题：

import Foundation// A disposable holds a `dispose` closure and calls it when it is releasedclass disposable {    let dispose: () -> VoID    init(_ dispose: @escaPing () -> VoID) { self.dispose = dispose }    deinit { dispose() }}class Box<T> {    typealias Listener = (T) -> VoID    // Replace your array with a dictionary mapPing    // I also made the Observer method mandatory. I don't belIEve it makes    // sense for it to be optional. I also made it private.    private var Listeners: [UUID: Listener] = [:]    var value: T {        dIDSet {            Listeners.values.forEach { 
// nothing but an array of disposables.class disposeBag {    private var disposables: [disposable] = []    func append(_ disposable: disposable) { disposables.append(disposable) }}extension disposable {    func disposed(by bag: disposeBag) {        bag.append(self)    }}var disposeBag: disposeBag? = disposeBag()b.bind { x in print("bag: \(x)") }    .disposed(by: disposeBag!)b.value = 100disposeBag = nilb.value = 500// Prints:// bag: 1// bag: 100// (Doesn't print "bag: 500")
(value) }        }    }    init(_ value: T){        self.value = value    }    // Now return a disposable. You'll get a warning if you fail    // to retain it (and it will immediately be destroyed)    func bind(Listener: @escaPing Listener) -> disposable {        // UUID is a nice way to create a unique IDentifIEr; that's what it's for        let IDentifIEr = UUID()        // Keep track of it        self.Listeners[IDentifIEr] = Listener        Listener(value)        // And create a disposable to clean it up later. The disposable        // doesn't have to kNow anything about T.         // Note that disposable has a strong referene to the Box        // This means the Box can't go away until the last observer has been removed        return disposable { self.Listeners.removeValue(forKey: IDentifIEr) }    }}let b = Box(10)var disposer: disposable? = b.bind(Listener: { x in print(x)})b.value = 5disposer = nilb.value = 1// Prints:// 10// 5// (Doesn't print 1)

这在某种程度上起了作用,我现在可以使用freshBind({}),只要我想删除旧的侦听器,但这也不是我想要的.我在观察UItableVIEwCells的值时必须使用它,但我还需要从其他地方观察相同的值.一旦细胞被重复使用,我就会移除旧的观察者以及我需要的其他观察者.

我现在有信心我需要一种方法来保留一个一次性物品,无论我以后想要处理它们.

我不够聪明,不能自己解决这个问题,所以我需要帮助.

我几乎没有使用过一些反应式编程框架(比如ReactiveCocoa),我现在明白为什么他们的订阅会返回我必须保留的disposable对象并在需要时处理掉.我需要这个功能.

我想要的是：func bind(Listener：Listener？) – > disposable {}

我的计划是创建一个名为disposable的类,其中包含(可选)侦听器,并将侦听器：[Listener？]转换为侦听器：[disposable],但我遇到了< T>的问题.

无法将’Box< String？> .disposable’类型的值转换为预期参数类型’Box< Any> .disposable’

任何聪明的建议？

解决方法 我想解决这个问题的方法是给每个观察者一个唯一的标识符(比如UUID)并使用它来允许disposable在时间上删除观察者.例如：

这可以很好地扩展到像disposeBag这样的概念：

很高兴自己构建一些这样的东西,以便了解它们的工作方式,但对于严肃的项目,这通常不够.主要问题是它不是线程安全的,所以如果在后台线程上处理某些东西,你可能会破坏整个系统.你当然可以使它成为线程安全的,并不是那么困难.

但后来你意识到你真的想要组成听众.您需要一个监听另一个监听器并转换它的监听器.所以你建立地图.然后你意识到你想要过滤值设置为旧值的情况,所以你建立一个“只发送给我不同的值”,然后你意识到你想要过滤器来帮助你,然后….

你意识到你正在重建RxSwift.

这根本不是避免编写自己的东西的原因,而且RxSwift包含许多项目从不需要的大量功能(可能太多功能),但随着你的进展,你应该继续问自己“我应该切换到RxSwift现在？”

总结

以上是内存溢出为你收集整理的ios – 使用“拳击”式的多重绑定和处理全部内容，希望文章能够帮你解决ios – 使用“拳击”式的多重绑定和处理所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。