Wenn ja, gibt es wesentliche Unterschiede, die bei Verwendung der Schlüsselwertbeobachtung in Objective-C nicht anderweitig vorhanden waren?

(Bearbeitet, um neue Informationen hinzuzufügen): Überlegen Sie, ob die Verwendung des Kombinations-Frameworks Ihnen dabei helfen kann, das zu erreichen, was Sie wollten, anstatt KVO zu verwenden

Ja und nein. KVO arbeitet wie immer an NSObject-Unterklassen. Es funktioniert nicht für Klassen, die NSObject nicht unterordnen. Swift verfügt (zumindest derzeit) nicht über ein eigenes natives Beobachtungssystem.

(In den Kommentaren erfahren Sie, wie Sie andere Eigenschaften als ObjC verfügbar machen, damit KVO daran arbeitet.)

Ein vollständiges Beispiel finden Sie in der Apple-Dokumentation .

Sie können KVO in Swift verwenden, jedoch nur für dynamicEigenschaften der NSObjectUnterklasse. Bedenken Sie, dass Sie die barEigenschaft einer FooKlasse beobachten möchten. Geben Sie in Swift 4 barals dynamicEigenschaft in Ihrer NSObjectUnterklasse Folgendes an:

class Foo: NSObject {
    @objc dynamic var bar = 0
}

Sie können sich dann registrieren, um Änderungen an der barEigenschaft zu beobachten . In Swift 4 und Swift 3.2 wurde dies erheblich vereinfacht, wie unter Verwenden der Schlüsselwertbeobachtung in Swift beschrieben :

class MyObject {
    private var token: NSKeyValueObservation

    var objectToObserve = Foo()

    init() {
        token = objectToObserve.observe(\.bar) { [weak self] object, change in  // the `[weak self]` is to avoid strong reference cycle; obviously, if you don't reference `self` in the closure, then `[weak self]` is not needed
            print("bar property is now \(object.bar)")
        }
    }
}

Beachten Sie, dass in Swift 4 jetzt Schlüsselpfade mit dem Backslash-Zeichen stark eingegeben werden (dies \.barist der Schlüsselpfad für die barEigenschaft des beobachteten Objekts). Da das Abschlussmuster für die Fertigstellung verwendet wird, müssen wir Beobachter nicht manuell entfernen (wenn der tokenGültigkeitsbereich ausfällt, wird der Beobachter für uns entfernt), und wir müssen uns auch nicht darum kümmern, die superImplementierung aufzurufen , wenn der Schlüssel dies nicht tut Spiel. Die Schließung wird nur aufgerufen, wenn dieser bestimmte Beobachter aufgerufen wird. Weitere Informationen finden Sie im WWDC 2017-Video " Was ist neu in Foundation?" .

Um dies zu beobachten, ist es in Swift 3 etwas komplizierter, aber sehr ähnlich zu dem, was man in Objective-C macht. Sie würden nämlich implementieren, observeValue(forKeyPath keyPath:, of object:, change:, context:)was (a) sicherstellt, dass wir uns mit unserem Kontext befassen (und nicht mit etwas, das unsere superInstanz zur Beobachtung registriert hat); und dann (b) entweder damit umgehen oder es nach superBedarf an die Implementierung weitergeben. Und stellen Sie sicher, dass Sie sich gegebenenfalls als Beobachter entfernen. Beispielsweise können Sie den Beobachter entfernen, wenn er freigegeben wird:

In Swift 3:

class MyObject: NSObject {
    private var observerContext = 0

    var objectToObserve = Foo()

    override init() {
        super.init()

        objectToObserve.addObserver(self, forKeyPath: #keyPath(Foo.bar), options: [.new, .old], context: &observerContext)
    }

    deinit {
        objectToObserve.removeObserver(self, forKeyPath: #keyPath(Foo.bar), context: &observerContext)
    }

    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        guard context == &observerContext else {
            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
            return
        }

        // do something upon notification of the observed object

        print("\(keyPath): \(change?[.newKey])")
    }

}

Beachten Sie, dass Sie nur Eigenschaften beobachten können, die in Objective-C dargestellt werden können. Daher können Sie keine Generika, Swift- structTypen, Swift- enumTypen usw. beobachten.

Eine Diskussion der Swift 2-Implementierung finden Sie in meiner ursprünglichen Antwort unten.

Unter Verwendung des dynamicKeyword - KVO zu erreichen mit NSObjectSubklassen in dem beschriebenen Schlüsselwert Observing Abschnitt der Annahme Cocoa Designs Konventionen Kapitel der Verwendung von Swift mit Cocoa und Objective-C Anleitung:

Das Beobachten von Schlüsselwerten ist ein Mechanismus, mit dem Objekte über Änderungen an bestimmten Eigenschaften anderer Objekte benachrichtigt werden können. Sie können die Schlüsselwertbeobachtung mit einer Swift-Klasse verwenden, solange die Klasse von der NSObjectKlasse erbt . Mit diesen drei Schritten können Sie die Schlüsselwertbeobachtung in Swift implementieren.

1. Fügen Sie den dynamicModifikator zu jeder Eigenschaft hinzu, die Sie beobachten möchten. Weitere Informationen dazu dynamicfinden Sie unter Erfordernis eines dynamischen Versands .

   class MyObjectToObserve: NSObject {
       dynamic var myDate = NSDate()
       func updateDate() {
           myDate = NSDate()
       }
   }
   

2. Erstellen Sie eine globale Kontextvariable.

   private var myContext = 0

3. Fügen Sie einen Beobachter für den Schlüsselpfad hinzu, überschreiben Sie die observeValueForKeyPath:ofObject:change:context:Methode und entfernen Sie den Beobachter in deinit.

   class MyObserver: NSObject {
       var objectToObserve = MyObjectToObserve()
       override init() {
           super.init()
           objectToObserve.addObserver(self, forKeyPath: "myDate", options: .New, context: &myContext)
       }
   
       override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) {
           if context == &myContext {
               if let newValue = change?[NSKeyValueChangeNewKey] {
                   print("Date changed: \(newValue)")
               }
           } else {
               super.observeValueForKeyPath(keyPath, ofObject: object, change: change, context: context)
           }
       }
   
       deinit {
           objectToObserve.removeObserver(self, forKeyPath: "myDate", context: &myContext)
       }
   }
   

[Beachten Sie, dass diese KVO-Diskussion später aus dem Handbuch „ Swift mit Kakao und Objective-C verwenden“ entfernt wurde, das für Swift 3 angepasst wurde, aber weiterhin wie oben in dieser Antwort beschrieben funktioniert.]

Es ist erwähnenswert, dass Swift über ein eigenes natives Eigenschaftsbeobachtungssystem verfügt, dies gilt jedoch für eine Klasse, die ihren eigenen Code angibt, der bei Beobachtung ihrer eigenen Eigenschaften ausgeführt wird. KVO hingegen ist so konzipiert, dass es sich registriert, um Änderungen an einer dynamischen Eigenschaft einer anderen Klasse zu beobachten.

Ja und Nein:

• Ja , Sie können dieselben alten KVO-APIs in Swift verwenden, um Objective-C-Objekte zu beobachten.
  Sie können auch dynamicEigenschaften von Swift-Objekten beobachten, von denen geerbt wird NSObject.
  Aber ... Nein, es ist nicht stark typisiert, wie man es von einem nativen Swift-Beobachtungssystem erwarten kann.
  Verwenden von Swift mit Kakao und Objective-C | Schlüsselwert beobachten

• Nein , derzeit gibt es kein eingebautes Wertebeobachtungssystem für beliebige Swift-Objekte.

• Ja , es gibt eingebaute Property Observers , die stark typisiert sind.
  Aber ... Nein, sie sind keine KVO, da sie nur die Beobachtung von Objekteigenschaften ermöglichen, keine verschachtelten Beobachtungen ("Schlüsselpfade") unterstützen und Sie diese explizit implementieren müssen.
  Die schnelle Programmiersprache | Immobilienbeobachter

• Ja , Sie können eine explizite Wertebeobachtung implementieren, die stark typisiert wird, das Hinzufügen mehrerer Handler aus anderen Objekten ermöglichen und sogar Verschachtelungs- / "Schlüsselpfade" unterstützen.
  Aber ... Nein, es wird kein KVO sein, da es nur für Eigenschaften funktioniert, die Sie als beobachtbar implementieren.
  Eine Bibliothek zur Implementierung einer solchen Wertebeobachtung finden Sie hier:
  Observable-Swift - KVO für Swift - Value Observing and Events

Ein Beispiel könnte hier ein wenig helfen. Wenn ich eine modelKlasseninstanz Modelmit Attributen habe nameund statediese Attribute beobachten kann mit:

let options = NSKeyValueObservingOptions([.New, .Old, .Initial, .Prior])

model.addObserver(self, forKeyPath: "name", options: options, context: nil)
model.addObserver(self, forKeyPath: "state", options: options, context: nil)

Änderungen an diesen Eigenschaften lösen einen Aufruf aus:

override func observeValueForKeyPath(keyPath: String!,
    ofObject object: AnyObject!,
    change: NSDictionary!,
    context: CMutableVoidPointer) {

        println("CHANGE OBSERVED: \(change)")
}

Ja.

KVO erfordert einen dynamischen Versand, daher müssen Sie den dynamicModifikator lediglich einer Methode, Eigenschaft, einem Index oder einem Initialisierer hinzufügen :

dynamic var foo = 0

Der dynamicModifikator stellt sicher, dass Verweise auf die Deklaration dynamisch gesendet und über abgerufen werden objc_msgSend.

Neben Robs Antwort. Diese Klasse muss von erben NSObject, und wir haben drei Möglichkeiten, um eine Eigenschaftsänderung auszulösen

Verwenden Sie setValue(value: AnyObject?, forKey key: String)vonNSKeyValueCoding

class MyObjectToObserve: NSObject {
    var myDate = NSDate()
    func updateDate() {
        setValue(NSDate(), forKey: "myDate")
    }
}

Verwenden Sie willChangeValueForKeyund didChangeValueForKeyvonNSKeyValueObserving

class MyObjectToObserve: NSObject {
    var myDate = NSDate()
    func updateDate() {
        willChangeValueForKey("myDate")
        myDate = NSDate()
        didChangeValueForKey("myDate")
    }
}

Verwenden Sie dynamic. Siehe Swift-Typkompatibilität

Sie können den dynamischen Modifikator auch verwenden, um zu verlangen, dass der Zugriff auf Mitglieder dynamisch über die Objective-C-Laufzeit verteilt wird, wenn Sie APIs wie Key-Value-Observing verwenden, die die Implementierung einer Methode dynamisch ersetzen.

class MyObjectToObserve: NSObject {
    dynamic var myDate = NSDate()
    func updateDate() {
        myDate = NSDate()
    }
}

Und Property Getter und Setter werden bei Verwendung aufgerufen. Sie können überprüfen, ob Sie mit KVO arbeiten. Dies ist ein Beispiel für eine berechnete Eigenschaft

class MyObjectToObserve: NSObject {
    var backing: NSDate = NSDate()
    dynamic var myDate: NSDate {
        set {
            print("setter is called")
            backing = newValue
        }
        get {
            print("getter is called")
            return backing
        }
    }
}

Überblick

Es ist möglich, Combineohne NSObjectoder zu verwendenObjective-C

Verfügbarkeit: iOS 13.0+ , macOS 10.15+, tvOS 13.0+, watchOS 6.0+, Mac Catalyst 13.0+,Xcode 11.0+

Hinweis: Muss nur mit Klassen verwendet werden, nicht mit Werttypen.

Code:

Schnelle Version: 5.1.2

import Combine //Combine Framework

//Needs to be a class doesn't work with struct and other value types
class Car {

    @Published var price : Int = 10
}

let car = Car()

//Option 1: Automatically Subscribes to the publisher

let cancellable1 = car.$price.sink {
    print("Option 1: value changed to \($0)")
}

//Option 2: Manually Subscribe to the publisher
//Using this option multiple subscribers can subscribe to the same publisher

let publisher = car.$price

let subscriber2 : Subscribers.Sink<Int, Never>

subscriber2 = Subscribers.Sink(receiveCompletion: { print("completion \($0)")}) {
    print("Option 2: value changed to \($0)")
}

publisher.subscribe(subscriber2)

//Assign a new value

car.price = 20

Ausgabe:

Option 1: value changed to 10
Option 2: value changed to 10
Option 1: value changed to 20
Option 2: value changed to 20

Verweisen:

• https://developer.apple.com/documentation/combine
• https://developer.apple.com/documentation/combine/receiving_and_handling_events_with_combine
• https://developer.apple.com/documentation/combine/published

Derzeit unterstützt Swift keinen eingebauten Mechanismus zum Beobachten von Eigenschaftsänderungen von anderen Objekten als 'self'. Nein, KVO wird nicht unterstützt.

KVO ist jedoch ein so grundlegender Bestandteil von Objective-C und Cocoa, dass es sehr wahrscheinlich ist, dass es in Zukunft hinzugefügt wird. Die aktuelle Dokumentation scheint dies zu implizieren:

Schlüsselwertbeobachtung

Informationen folgen.

Verwenden von Swift mit Cocoa und Objective-C

Eine wichtige Sache zu erwähnen ist, dass nach dem Aktualisieren Ihres Xcodes auf 7 Beta möglicherweise die folgende Meldung angezeigt wird: "Methode überschreibt keine Methode aus ihrer Oberklasse" . Das liegt an der Optionalität der Argumente. Stellen Sie sicher, dass Ihr Beobachtungshandler genau wie folgt aussieht:

override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [NSObject : AnyObject]?, context: UnsafeMutablePointer<Void>)

Dies kann sich für wenige Menschen als hilfreich erweisen -

// MARK: - KVO

var observedPaths: [String] = []

func observeKVO(keyPath: String) {
    observedPaths.append(keyPath)
    addObserver(self, forKeyPath: keyPath, options: [.old, .new], context: nil)
}

func unObserveKVO(keyPath: String) {
    if let index = observedPaths.index(of: keyPath) {
        observedPaths.remove(at: index)
    }
    removeObserver(self, forKeyPath: keyPath)
}

func unObserveAllKVO() {
    for keyPath in observedPaths {
        removeObserver(self, forKeyPath: keyPath)
    }
}

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if let keyPath = keyPath {
        switch keyPath {
        case #keyPath(camera.iso):
            slider.value = camera.iso
        default:
            break
        }
    }
}

Ich hatte KVO in Swift 3 auf diese Weise verwendet. Sie können diesen Code mit wenigen Änderungen verwenden.

Ein weiteres Beispiel für alle, die auf ein Problem mit Typen wie Int? und CGFloat?. Sie legen Ihre Klasse einfach als Unterklasse von NSObject fest und deklarieren Ihre Variablen wie folgt, z.

class Theme : NSObject{

   dynamic var min_images : Int = 0
   dynamic var moreTextSize : CGFloat = 0.0

   func myMethod(){
       self.setValue(value, forKey: "\(min_images)")
   }

}