ios - RXSwift，一个作为变量的结构

Question

所以基本上我有一个结构

struct MyStruct {
    var foo : String = "" 
    var bar : String = ""
}

现在我想做以下事情:观察 MyStruct 的 RxVariable 中的变化，以便每当该变量发生变化时，我们也有该变量的观察者，我们将能够在该观察者中获取新结构。

再次明确——

A 级

var stct : Variable<MyStruct>() // RxSwift variable

B 类:

 let observer = instanceClassA.stct.asObserver().subscribe(onNext : 
  {(newStruct) in 
       // newStruct found here -
  }
 observer.dispose(by:disposeBag)

我想要这个流程的原因是:我想要Class B知道什么时候Class A's myStruct 的变量已更改为新值，每次 myStruct变量变化，foo和 bar , 也会改变

可以认为类 B 是类 A 的 myStruct 变量的观察者。现在我正在学习 RxSwift，因此我想利用它的响应式方法。我也认为这是一件相当容易的事情，但问题是我无法制作 Variable (read : Rx)。的 MyStruct

P.S - 我使用的是 Swift 4.0 和 RxSwift 的最新版本。

非常感谢任何帮助。

Answer 1

为什么不使用 distinctUntilChanged 运算符？

您可以使您的结构符合 Equatable 并且 distinctUntilChanged 运算符将以这种方式工作:

struct MyStruct: Equatable {

    var foo : String = ""
    var bar : String = ""

    static func ==(lhs: MyStruct, rhs: MyStruct) -> Bool {
        return lhs.bar == rhs.bar && lhs.foo == rhs.foo
    }
}

func observableStctChangedByEquatable() -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged()
}

let observer = instanceClassA
    .observableStctChangedByEquatable()
    .subscribe(onNext: { (newStruct) in
        //
    })

如果您不喜欢 Equatable，还有一些其他方法可以使用 distinctUntilChanged 运算符。选择您最喜欢的一个:

struct MyStruct {

    var foo : String = ""
    var bar : String = ""

    static func comparer(lhs: MyStruct, rhs: MyStruct) throws -> Bool {
        return lhs.bar == rhs.bar && lhs.foo == rhs.foo
    }
}

func observableStctChangedByComparer() -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged(MyStruct.comparer)
}

func observableStctChangedByBlock() -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged({ (lhs, rhs) -> Bool in
            return lhs.bar == rhs.bar && lhs.foo == rhs.foo
        })
}

func observableStctChangedWith(comparer: @escaping (MyStruct, MyStruct) throws -> Bool) -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged(comparer)
}

let observer = instanceClassA
    .observableStctChangedWith(comparer: { (lhs, rhs) -> Bool in
        return lhs.bar == rhs.bar && lhs.foo == rhs.foo
    })
    .subscribe(onNext: { (newStruct) in
        //
    })