我正在考虑使用自己的自定义信号框架将项目转换为使用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的更新，同时将其所有依赖关系更新为新状态，并且仅在完成后才允许更新的方法？
答案 0 :(得分：0)
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
}
如果您已安装Xcode 11 Beta，则甚至可以使用基于新的@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 = 20