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

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")

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

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

你意识到你正在重建RxSwift.

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