这是一个非常具体和冗长的问题，但我不够聪明，无法自己解决..

我对 this YouTube-video 很感兴趣来自 raywenderlich.com，它使用“装箱”方法观察值。

他们的 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.
}

每当设置这样的绑定(bind)时，之前的绑定(bind)将被释放，因为 Box替换 listener与新的听众。

我需要能够从不同的地方观察到相同的值。我修改了 Box像这样:

class Box<T> {
    typealias Listener = (T) -> Void
    var listeners:[Listener?] = []

    var value:T{
        didSet{
            listeners.forEach({$0?(value)})
        }
    }
    init(_ value:T){
        self.value = value
    }
    func bind(listener:Listener?){
        self.listeners.append(listener)
        listener?(value)
    }
}

但是 - 这也给我带来了麻烦，显然..有些地方我想要新绑定(bind)删除旧绑定(bind)。例如，如果我从可重用 UITableViewCell 中观察对象中的值, 滚动时会绑定(bind)几次。我现在需要一种可控的方式来处理特定的绑定(bind)。

我试图通过将这个函数添加到 Box 来解决这个问题:

func freshBind(listener:Listener?){
    self.listeners.removeAll()
    self.bind(listener)
}

这在某种程度上起作用了，我现在可以使用 freshBind({})每当我想删除旧的听众时，但这也不是我想要的。在观察来自 UITableViewCell 的值时，我必须使用它s，但我还需要从其他地方观察到相同的值。一旦单元被重用，我就删除了旧的观察者以及我需要的其他观察者。

我现在确信我需要一种方法来保留一次性元素，无论我以后想把它们放在什么地方。

我不够聪明，无法自己解决这个问题，所以我需要帮助。

我几乎没有使用过一些响应式编程框架(比如 ReactiveCocoa)，现在我明白了为什么他们的订阅会返回 Disposable我必须保留并在需要时处理的元素。我需要这个功能。

我想要的是:func bind(listener:Listener?)->Disposable{}

我的计划是创建一个名为 Disposable 的类其中包含(可选)监听器，然后转 listeners:[Listener?]进入listeners:[Disposable] , 但我遇到了 <T> 的问题..

Cannot convert value of type 'Box<String?>.Disposable' to expected argument type 'Box<Any>.Disposable'

有什么聪明的建议吗？

最佳答案

我想解决这个问题的方法是给每个观察者一个唯一的标识符(比如 UUID)，并使用它来允许 Disposable 在适当的时候移除观察者。例如:

import Foundation

// A Disposable holds a `dispose` closure and calls it when it is released
class 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 { $0(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 = 5
disposer = nil
b.value = 1

// Prints:
// 10
// 5
// (Doesn't print 1)

这可以很好地扩展到像 DisposeBag 这样的概念:

// 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 = 100
disposeBag = nil
b.value = 500

// Prints:
// bag: 1
// bag: 100
// (Doesn't print "bag: 500")

自己构建一些这样的东西很好，这样您就可以了解它们的工作原理，但对于严肃的项目来说，这通常是不够的。主要问题是它不是线程安全的，因此如果在后台线程上处理某些内容，您可能会破坏整个系统。您当然可以使其成为线程安全的，这并不难。

但后来您意识到您真的想要编写听众。您需要一个监听器来观察另一个监听器并对其进行转换。所以你构建 map 。然后你意识到你想要过滤值被设置为其旧值的情况，所以你构建了一个“只向我发送不同的值”然后你意识到你想要 filter 来帮助你，并且然后....

你意识到你正在重建 RxSwift。

这根本不是避免自己编写的理由，RxSwift 包含许多项目永远不需要的大量功能(可能是太多的功能)，但是在进行过程中，您应该不断问自己“我应该现在切换到 RxSwift 了吗？”

关于ios - 使用 "Boxing"样式的多重绑定(bind)和处置，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50135742/