使用 keyPath 绑定 2 个属性（观察）

Question

我正在尝试创建一个例程来简化将一个属性绑定到另一个，这是一个非常常见的操作。我在 Swift 4 和 XCode 9.

中使用基于块的 KVO

我希望能够编写以下内容以使用相应的 keyPath 绑定两个变量：

self.bind(to: \BindMe.myFirstName, from: \BindMe.person.firstName )

这是一个简化的示例，它生成了我无法解决的各种编译错误。可能是将 keyPath 错误地传递给 func bind，但是使用 keyPath 的 setValue 也无法编译。请查看代码中的注释以了解我遇到的编译错误。

class Person : NSObject
{
    init( firstName:String, lastName:String )
    {
        self.firstName  = firstName
        self.lastName   = lastName
    }

    @objc dynamic var firstName:String
    @objc dynamic var lastName:String
}

class BindMe : NSObject
{
    var observers   = [NSKeyValueObservation]()
    let person:Person

    var myFirstName:String = "<no first name>"
    var myLastName:String  = "<no last name>"

    init( person:Person )
    {
        self.person = person
        self.setupBindings()
    }

    func setupBindings()
    {
        self.bind(to: \BindMe.myFirstName, from: \BindMe.person.firstName )
        self.bind(to: \BindMe.myLastName,  from: \BindMe.person.lastName )
    }

    // this func declaration is likely incorrect
    func bind<T,Value,Value2>( to targetKeyPath:KeyPath<T,Value>, from sourceKeyPath:KeyPath<T,Value2>)
    {
        // Error: Generic parameter 'Value' could not be inferred
        self.observers.append( self.observe(sourceKeyPath, options: [.initial,.new], changeHandler: { (object, change) in

            // Error: Cannot convert value of type 'KeyPath<T, Value>' to expected argument type 'String'
            self.setValue(change.newValue, forKeyPath: targetKeyPath)
        }))
    }
}

编辑

有助于解决最初的编译问题。但是，为了使它真正有用，我需要能够将管道推入 superclass 中，如此处所示。这将使 class 使用起来非常简单，但我仍在为编译错误而苦苦挣扎：

Cannot invoke 'bind' with an argument list of type '(to: WritableKeyPath<PersonWatcher, PersonWatcher>, from: WritableKeyPath<PersonWatcher, PersonWatcher>)'

如果我将通用类型 T 传递给绑定例程，则会收到此错误：

Type 'BindBase' has no subscript members

class BindBase :NSObject
{
    var observers = [NSKeyValueObservation]()

    func bind<Value>(to targetKeyPath: ReferenceWritableKeyPath<BindBase, Value>, from sourceKeyPath: KeyPath<BindBase, Value>)
    {
        self.observers.append(self.observe(sourceKeyPath, options: [.initial, .new], changeHandler: { (object, change) in
            self[keyPath: targetKeyPath] = change.newValue!
        }))
    }
}

class PersonWatcher : BindBase
{
    @objc dynamic var person: Person

    @objc var myFirstName: String = "<no first name>"
    @objc var myLastName:  String = "<no last name>"

    init(person: Person) {
        self.person = person
        super.init()

        self.bind(to: \PersonWatcher.myFirstName, from: \PersonWatcher.person.firstName)
        self.bind(to: \PersonWatcher.myLastName,  from: \PersonWatcher.person.lastName)
    }
}

Answer 1

根据已接受的提议 SE-0161 Smart KeyPaths: Better Key-Value Coding for Swift，您需要使用 ReferenceWritableKeyPath 将值写入具有引用语义的对象的键路径，使用下标。

（您需要将经典的基于 String 的密钥路径传递给 setValue(_:forKeyPath:)，而不是 KeyPath。）

还有一些：

Value 和 Value2 需要相同才能赋值
T需要表示self
KVC/KVO 目标属性需要 @objc
BindMe.init(person:) 需要 super.init()

所以，你的 BindMe 应该是这样的：

class BindMe: NSObject {
    var observers = [NSKeyValueObservation]()
    @objc let person: Person

    @objc var myFirstName: String = "<no first name>"
    @objc var myLastName: String  = "<no last name>"

    init(person: Person) {
        self.person = person
        super.init()
        self.setupBindings()
    }

    func setupBindings() {
        self.bind(to: \BindMe.myFirstName, from: \BindMe.person.firstName)
        self.bind(to: \BindMe.myLastName,  from: \BindMe.person.lastName)
    }

    func bind<Value>(to targetKeyPath: ReferenceWritableKeyPath<BindMe, Value>, from sourceKeyPath: KeyPath<BindMe, Value>) {
        self.observers.append(self.observe(sourceKeyPath, options: [.initial, .new], changeHandler: { (object, change) in
            self[keyPath: targetKeyPath] = change.newValue!
        }))
    }
}

对于编辑：

要求做一个BindBase之类的东西似乎很合理，所以我做了一些尝试。

实现

T需要表示self

(where T == KeyPath.Root)，使用Self是最直观的，但不幸的是，在Swift.[=32=的当前版本中，它的使用仍然受到很大限制。 ]

您可以使用 Self 将 bind 的定义移动到协议扩展中：

class BindBase: NSObject, Bindable {
    var observers = [NSKeyValueObservation]()
}

protocol Bindable: class {
    var observers: [NSKeyValueObservation] {get set}
}

extension Bindable {
    func bind<Value>(to targetKeyPath: ReferenceWritableKeyPath<Self, Value>, from sourceKeyPath: KeyPath<Self, Value>)
    where Self: NSObject
    {
        let observer = self.observe(sourceKeyPath, options: [.initial, .new]) {object, change in
            self[keyPath: targetKeyPath] = change.newValue!
        }
        self.observers.append(observer)
    }
}

使用 keyPath 绑定 2 个属性（观察）

Binding 2 properties (observe) using keyPath

swift

swift4