gpt4 book ai didi

ios - 使用 "Boxing"样式的多重绑定(bind)和处置

转载 作者:搜寻专家 更新时间:2023-10-30 21:54:18 25 4
gpt4 key购买 nike

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

我对 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/

25 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com