在ReactiveSwift中同步组合属性
我正在考虑使用我自己的自定义signal框架将项目转换为使用ReactiveSwift，但有一个基本问题我从未想过如何在ReactiveSwift中解决：
作为一个简化的示例，假设您有两个可变属性：
let a = MutableProperty<Int>(1)
let b = MutableProperty<Int>(2)然后，我们派生一个结合了这两个属性的属性来实现我们的逻辑：
let c = Property.combineLatest(a, b).map { a, b in
return a + b
}稍后，我们收到一些信息，这些信息促使我们同时更新a和b的值：
a.value = 3
b.value = 4现在的问题是，c将通知它的侦听器它具有值3 -> 5 -> 7。5完全是虚假的，并不代表有效的状态，因为我们从来不希望a等于3而b等于2的状态。
有什么办法可以解决这个问题吗？一种方法，可以抑制对Property的更新，同时将其所有依赖项更新为新状态，并且只在完成后才允许更新？
回答 1
Stack Overflow用户
发布于 2019-06-27 07:42:52
combineLatest的基本目的是在其上游输入发送新值时发送一个值，所以如果您想使用该运算符，我认为没有办法避免这个问题。
如果两个值真正同时更新很重要，那么可以考虑使用MutableProperty<(Int, Int)>或将这两个值放在一个结构中。如果你给出更多关于你实际试图完成的内容的上下文，那么也许我们可以给出一个更好的答案。
暂停更新
因此，我真的不推荐这样做，但如果你想要一个通用的技术来“暂停”更新，那么你可以用一个全局变量来指示更新是否暂停，并使用filter操作符：
let a = MutableProperty<Int>(1)
let b = MutableProperty<Int>(2)
var pauseUpdates = false
let c = Property.combineLatest(a, b)
.filter(initial: (0, 0)) { _ in !pauseUpdates }
.map { a, b in
return a + b
}
func update(newA: Int, newB: Int) {
pauseUpdates = true
a.value = newA
pauseUpdates = false
b.value = newB
}
c.producer.startWithValues { c in print(c) }
update(newA: 3, newB: 4)但是，可能有更好的特定于上下文的解决方案来实现您想要实现的目标。
使用采样器手动触发更新
另一种解决方案是使用sample运算符手动选择何时取值：
class MyClass {
let a = MutableProperty<Int>(1)
let b = MutableProperty<Int>(2)
let c: Property<Int>
private let sampler: Signal<Void, Never>.Observer
init() {
let (signal, input) = Signal<Void, Never>.pipe()
sampler = input
let updates = Property.combineLatest(a, b)
.map { a, b in
return a + b
}
.producer
.sample(with: signal)
.map { $0.0 }
c = Property(initial: a.value + b.value, then: updates)
}
func update(a: Int, b: Int) {
self.a.value = a
self.b.value = b
sampler.send(value: ())
}
}
let x = MyClass()
x.c.producer.startWithValues { c in print(c) }
x.update(a: 3, b: 4)使用zip
如果a和b总是一起更改，您可以使用zip运算符，它会等待两个输入都有新值：
let a = MutableProperty<Int>(1)
let b = MutableProperty<Int>(2)
let c = Property.zip(a, b).map(+)
c.producer.startWithValues { c in print(c) }
a.value = 3
b.value = 4对每种类型的更新使用带有方法的zip
class MyClass {
let a = MutableProperty<Int>(1)
let b = MutableProperty<Int>(2)
let c: Property<Int>
init() {
c = Property.zip(a, b).map(+)
}
func update(a: Int, b: Int) {
self.a.value = a
self.b.value = b
}
func update(a: Int) {
self.a.value = a
self.b.value = self.b.value
}
func update(b: Int) {
self.a.value = self.a.value
self.b.value = b
}
}
let x = MyClass()
x.c.producer.startWithValues { c in print(c) }
x.update(a: 5)
x.update(b: 7)
x.update(a: 8, b: 8)将这些值组合到一个结构中
尽管您说您不想这样做，但我还是想提供一个这样的示例，因为MutableProperty有一个modify方法，它使它不像您想象的那样繁琐：
struct Values {
var a: Int
var b: Int
}
let ab = MutableProperty(Values(a: 1, b: 2))
let c = ab.map { $0.a + $0.b }
c.producer.startWithValues { c in print(c) }
ab.modify { values in
values.a = 3
values.b = 4
}您甚至可以拥有方便的属性来直接访问a和b，即使ab属性是事实的来源：
let a = ab.map(\.a)
let b = ab.map(\.b)创建新类型的可变属性以包装复合属性
您可以创建一个符合MutablePropertyProtocol的新类，使其更符合人体工程学，使用结构来保存您的值：
class MutablePropertyWrapper<T, U>: MutablePropertyProtocol {
typealias Value = U
var value: U {
get { property.value[keyPath: keyPath] }
set {
property.modify { val in
var newVal = val
newVal[keyPath: self.keyPath] = newValue
val = newVal
}
}
}
var lifetime: Lifetime {
property.lifetime
}
var producer: SignalProducer<U, Never> {
property.map(keyPath).producer
}
var signal: Signal<U, Never> {
property.map(keyPath).signal
}
private let property: MutableProperty<T>
private let keyPath: WritableKeyPath<T, U>
init(_ property: MutableProperty<T>, keyPath: WritableKeyPath<T, U>) {
self.property = property
self.keyPath = keyPath
}
}这样，您就可以创建a和b的可变版本，从而方便地获取和设置值：
struct Values {
var a: Int
var b: Int
}
let ab = MutableProperty(Values(a: 1, b: 2))
let a = MutablePropertyWrapper(ab, keyPath: \.a)
let b = MutablePropertyWrapper(ab, keyPath: \.b)
let c = ab.map { $0.a + $0.b }
c.producer.startWithValues { c in print(c) }
// Update the values individually, triggering two updates
a.value = 10
b.value = 20
// Update both values atomically, triggering a single update
ab.modify { values in
values.a = 30
values.b = 40
}如果你已经安装了Xcode11Beta，你甚至可以使用新的基于键路径的@dynamicMemberLookup特性来使这更符合人体工程学：
@dynamicMemberLookup
protocol MemberAccessingProperty: MutablePropertyProtocol {
subscript<U>(dynamicMember keyPath: WritableKeyPath<Value, U>) -> MutablePropertyWrapper<Value, U> { get }
}
extension MutableProperty: MemberAccessingProperty {
subscript<U>(dynamicMember keyPath: WritableKeyPath<Value, U>) -> MutablePropertyWrapper<Value, U> {
return MutablePropertyWrapper(self, keyPath: keyPath)
}
}现在，不是：
let a = MutablePropertyWrapper(ab, keyPath: \.a)
let b = MutablePropertyWrapper(ab, keyPath: \.b)你可以这样写：
let a = ab.a
let b = ab.b或者直接设置这些值，而不创建单独的变量：
ab.a.value = 10
ab.b.value = 20https://stackoverflow.com/questions/56780610
复制相似问题