Swift hat eine Eigenschaftsdeklarationssyntax, die der von C # sehr ähnlich ist:

var foo: Int {
    get { return getFoo() }
    set { setFoo(newValue) }
}

Es hat aber auch willSetund didSetAktionen. Diese werden vor bzw. nach dem Aufruf des Setters aufgerufen. Was ist ihr Zweck, wenn man bedenkt, dass Sie nur den gleichen Code im Setter haben könnten?

Der Punkt scheint zu sein, dass Sie manchmal eine Eigenschaft benötigen, die über automatischen Speicher und ein gewisses Verhalten verfügt, um beispielsweise andere Objekte darüber zu informieren, dass sich die Eigenschaft gerade geändert hat. Wenn Sie nur get/ haben set, benötigen Sie ein anderes Feld, um den Wert zu speichern. Mit willSetund didSetkönnen Sie Maßnahmen ergreifen, wenn der Wert geändert wird, ohne dass ein weiteres Feld erforderlich ist. Zum Beispiel in diesem Beispiel:

class Foo {
    var myProperty: Int = 0 {
        didSet {
            print("The value of myProperty changed from \(oldValue) to \(myProperty)")
        }
    }
}

myPropertyGibt bei jeder Änderung den alten und den neuen Wert aus. Mit nur Getter und Setter würde ich dies stattdessen brauchen:

class Foo {
    var myPropertyValue: Int = 0
    var myProperty: Int {
        get { return myPropertyValue }
        set {
            print("The value of myProperty changed from \(myPropertyValue) to \(newValue)")
            myPropertyValue = newValue
        }
    }
}

So willSetund didSetstellt eine Wirtschaft von ein paar Zeilen, und weniger Lärm in der Feldliste.

Ich verstehe, dass set und get für berechnete Eigenschaften gelten (keine Sicherung von gespeicherten Eigenschaften ).

_{Wenn Sie von einem Objective-C kommen, denken Sie daran, dass sich die Namenskonventionen geändert haben. In Swift wird eine iVar- oder Instanzvariable als gespeicherte Eigenschaft bezeichnet}

Beispiel 1 (schreibgeschützte Eigenschaft) - mit Warnung:

var test : Int {
    get {
        return test
    }
}

Dies führt zu einer Warnung, da dies zu einem rekursiven Funktionsaufruf führt (der Getter ruft sich selbst auf). Die Warnung in diesem Fall lautet "Versuch, 'Test' in seinem eigenen Getter zu ändern".

Beispiel 2. Bedingtes Lesen / Schreiben - mit Warnung

var test : Int {
    get {
        return test
    }
    set (aNewValue) {
        //I've contrived some condition on which this property can be set
        //(prevents same value being set)
        if (aNewValue != test) {
            test = aNewValue
        }
    }
}

Ähnliches Problem - Sie können dies nicht tun, da der Setter rekursiv aufgerufen wird. Beachten Sie außerdem, dass sich dieser Code nicht über keine Initialisierer beschwert, da keine zu initialisierende Eigenschaft gespeichert ist .

Beispiel 3. Berechnete Lese- / Schreibeigenschaft - mit Hintergrundspeicher

Hier ist ein Muster, das die bedingte Einstellung einer tatsächlich gespeicherten Eigenschaft ermöglicht

//True model data
var _test : Int = 0

var test : Int {
    get {
        return _test
    }
    set (aNewValue) {
        //I've contrived some condition on which this property can be set
        if (aNewValue != test) {
            _test = aNewValue
        }
    }
}

Hinweis Die tatsächlichen Daten heißen _test (obwohl es sich um beliebige Daten oder Datenkombinationen handeln kann). Beachten Sie auch die Notwendigkeit, einen Anfangswert anzugeben (alternativ müssen Sie eine init-Methode verwenden), da _test tatsächlich eine Instanzvariable ist

Beispiel 4. Verwenden von will und did set

//True model data
var _test : Int = 0 {

    //First this
    willSet {
        println("Old value is \(_test), new value is \(newValue)")
    }

    //value is set

    //Finaly this
    didSet {
        println("Old value is \(oldValue), new value is \(_test)")
    }
}

var test : Int {
    get {
        return _test
    }
    set (aNewValue) {
        //I've contrived some condition on which this property can be set
        if (aNewValue != test) {
            _test = aNewValue
        }
    }
}

Hier sehen wir, wie willSet und didSet eine Änderung in einer tatsächlich gespeicherten Eigenschaft abfangen. Dies ist nützlich zum Senden von Benachrichtigungen, Synchronisieren usw. (siehe Beispiel unten).

Beispiel 5. Konkretes Beispiel - ViewController Container

//Underlying instance variable (would ideally be private)
var _childVC : UIViewController? {
    willSet {
        //REMOVE OLD VC
        println("Property will set")
        if (_childVC != nil) {
            _childVC!.willMoveToParentViewController(nil)
            self.setOverrideTraitCollection(nil, forChildViewController: _childVC)
            _childVC!.view.removeFromSuperview()
            _childVC!.removeFromParentViewController()
        }
        if (newValue) {
            self.addChildViewController(newValue)
        }

    }

    //I can't see a way to 'stop' the value being set to the same controller - hence the computed property

    didSet {
        //ADD NEW VC
        println("Property did set")
        if (_childVC) {
//                var views  = NSDictionaryOfVariableBindings(self.view)    .. NOT YET SUPPORTED (NSDictionary bridging not yet available)

            //Add subviews + constraints
            _childVC!.view.setTranslatesAutoresizingMaskIntoConstraints(false)       //For now - until I add my own constraints
            self.view.addSubview(_childVC!.view)
            let views = ["view" : _childVC!.view] as NSMutableDictionary
            let layoutOpts = NSLayoutFormatOptions(0)
            let lc1 : AnyObject[] = NSLayoutConstraint.constraintsWithVisualFormat("|[view]|",  options: layoutOpts, metrics: NSDictionary(), views: views)
            let lc2 : AnyObject[] = NSLayoutConstraint.constraintsWithVisualFormat("V:|[view]|", options: layoutOpts, metrics: NSDictionary(), views: views)
            self.view.addConstraints(lc1)
            self.view.addConstraints(lc2)

            //Forward messages to child
            _childVC!.didMoveToParentViewController(self)
        }
    }
}


//Computed property - this is the property that must be used to prevent setting the same value twice
//unless there is another way of doing this?
var childVC : UIViewController? {
    get {
        return _childVC
    }
    set(suggestedVC) {
        if (suggestedVC != _childVC) {
            _childVC = suggestedVC
        }
    }
}

Beachten Sie die Verwendung von BEIDEN berechneten und gespeicherten Eigenschaften. Ich habe eine berechnete Eigenschaft verwendet, um zu verhindern, dass derselbe Wert zweimal festgelegt wird (um zu verhindern, dass schlimme Dinge passieren!). Ich habe willSet und didSet verwendet, um Benachrichtigungen an viewController weiterzuleiten (siehe UIViewController-Dokumentation und Informationen zu viewController-Containern).

Ich hoffe das hilft und bitte jemanden schreien, wenn ich hier irgendwo einen Fehler gemacht habe!

Diese werden als Immobilienbeobachter bezeichnet :

Immobilienbeobachter beobachten und reagieren auf Wertänderungen einer Immobilie. Eigenschaftsbeobachter werden jedes Mal aufgerufen, wenn der Wert einer Eigenschaft festgelegt wird, auch wenn der neue Wert mit dem aktuellen Wert der Eigenschaft übereinstimmt.

Auszug aus: Apple Inc. "Die schnelle Programmiersprache". iBooks. https://itun.es/ca/jEUH0.l

Ich vermute, es soll Dinge berücksichtigen, die wir traditionell mit KVO tun würden, wie Datenbindung mit UI-Elementen oder Auslösen von Nebenwirkungen beim Ändern einer Eigenschaft, Auslösen eines Synchronisierungsprozesses, Hintergrundverarbeitung usw. usw.

HINWEIS

willSetund didSetBeobachter werden nicht aufgerufen, wenn eine Eigenschaft in einem Initialisierer festgelegt wird, bevor die Delegierung stattfindet

Sie können didSetdie Variable auch verwenden , um die Variable auf einen anderen Wert zu setzen. Dies führt nicht dazu, dass der Beobachter erneut angerufen wird, wie im Eigenschaftenhandbuch angegeben . Dies ist beispielsweise hilfreich, wenn Sie den Wert wie folgt begrenzen möchten:

let minValue = 1

var value = 1 {
    didSet {
        if value < minValue {
            value = minValue
        }
    }
}

value = -10 // value is minValue now.

Die vielen gut geschriebenen Antworten decken die Frage gut ab, aber ich werde im Detail eine Ergänzung erwähnen, die meiner Meinung nach eine Behandlung wert ist.

Die willSetund didSet-Eigenschaftsbeobachter können zum Aufrufen von Delegaten verwendet werden, z. B. für Klasseneigenschaften, die immer nur durch Benutzerinteraktion aktualisiert werden, bei denen Sie jedoch vermeiden möchten, dass der Delegat bei der Objektinitialisierung aufgerufen wird.

Ich zitiere Klaas hochgestimmten Kommentar zur akzeptierten Antwort:

willSet- und didSet-Beobachter werden beim ersten Initialisieren einer Eigenschaft nicht aufgerufen. Sie werden nur aufgerufen, wenn der Wert der Eigenschaft außerhalb eines Initialisierungskontexts festgelegt wird.

Dies ist recht ordentlich, da es bedeutet, dass die didSetEigenschaft beispielsweise eine gute Wahl für den Startpunkt für delegierte Rückrufe und Funktionen für Ihre eigenen benutzerdefinierten Klassen ist.

Betrachten Sie als Beispiel ein benutzerdefiniertes Benutzersteuerungsobjekt mit einer Schlüsseleigenschaft value(z. B. Position in der Bewertungssteuerung), die als Unterklasse von UIView:

// CustomUserControl.swift
protocol CustomUserControlDelegate {
    func didChangeValue(value: Int)
    // func didChangeValue(newValue: Int, oldValue: Int)
    // func didChangeValue(customUserControl: CustomUserControl)
    // ... other more sophisticated delegate functions
}

class CustomUserControl: UIView {

    // Properties
    // ...
    private var value = 0 {
        didSet {
            // Possibly do something ...

            // Call delegate.
            delegate?.didChangeValue(value)
            // delegate?.didChangeValue(value, oldValue: oldValue)
            // delegate?.didChangeValue(self)
        }
    }

    var delegate: CustomUserControlDelegate?

    // Initialization
    required init?(...) { 
        // Initialise something ...

        // E.g. 'value = 1' would not call didSet at this point
    }

    // ... some methods/actions associated with your user control.
}

Danach können Ihre Delegatenfunktionen beispielsweise in einigen View-Controllern verwendet werden, um wichtige Änderungen im Modell zu beobachten CustomViewController, ähnlich wie Sie die inhärenten Delegatenfunktionen der UITextFieldDelegatefor- UITextFieldObjekte (z textFieldDidEndEditing(...). B. ) verwenden würden.

Verwenden Sie für dieses einfache Beispiel einen Delegatenrückruf von der didSetEigenschaft class value, um einem Ansichtscontroller mitzuteilen, dass einem seiner Outlets eine Modellaktualisierung zugeordnet ist:

// ViewController.swift
Import UIKit
// ...

class ViewController: UIViewController, CustomUserControlDelegate {

    // Properties
    // ...
    @IBOutlet weak var customUserControl: CustomUserControl!

    override func viewDidLoad() {
        super.viewDidLoad()
        // ...

        // Custom user control, handle through delegate callbacks.
        customUserControl = self
    }

    // ...

    // CustomUserControlDelegate
    func didChangeValue(value: Int) {
        // do some stuff with 'value' ...
    }

    // func didChangeValue(newValue: Int, oldValue: Int) {
        // do some stuff with new as well as old 'value' ...
        // custom transitions? :)
    //}

    //func didChangeValue(customUserControl: CustomUserControl) {
    //    // Do more advanced stuff ...
    //}
}

Hier wurde die valueEigenschaft gekapselt, aber im Allgemeinen: Achten Sie in solchen Situationen darauf, die valueEigenschaft des customUserControlObjekts nicht im Bereich der zugehörigen Delegatenfunktion (hier :) didChangeValue()im Ansichts-Controller zu aktualisieren, da dies sonst der Fall ist unendliche Rekursion.

Die Beobachter willSet und didSet für die Eigenschaften, wenn der Eigenschaft ein neuer Wert zugewiesen wird. Dies gilt auch dann, wenn der neue Wert mit dem aktuellen Wert übereinstimmt.

Beachten Sie, dass willSetein Parametername didSeterforderlich ist , um dies zu umgehen.

Der didSet-Beobachter wird aufgerufen, nachdem der Wert der Eigenschaft aktualisiert wurde. Es vergleicht sich mit dem alten Wert. Wenn sich die Gesamtzahl der Schritte erhöht hat, wird eine Meldung gedruckt, die angibt, wie viele neue Schritte ausgeführt wurden. Der didSet-Beobachter gibt keinen benutzerdefinierten Parameternamen für den alten Wert an, und stattdessen wird der Standardname von oldValue verwendet.

Getter und Setter sind manchmal zu schwer zu implementieren, um die richtigen Wertänderungen zu beobachten. Normalerweise erfordert dies eine zusätzliche vorübergehende Variablenbehandlung und zusätzliche Überprüfungen, und Sie sollten selbst diese winzige Arbeit vermeiden, wenn Sie Hunderte von Gettern und Setzern schreiben. Diese Sachen sind für die Situation.

In Ihrer eigenen (Basis-) Klasse willSetund didSetsind ziemlich redundant , da Sie stattdessen eine berechnete Eigenschaft definieren können (dh get- und set-Methoden), die auf a zugreift und _propertyVariabledie gewünschte Vor- und Nachbearbeitung ausführt .

Wenn jedoch , Sie eine Klasse außer Kraft setzen , wenn die Eigenschaft bereits definiert , dann das willSetund didSetsind nützlich und nicht überflüssig!

Eine Sache, die didSetwirklich praktisch ist, ist, wenn Sie Steckdosen verwenden, um zusätzliche Konfiguration hinzuzufügen.

@IBOutlet weak var loginOrSignupButton: UIButton! {
  didSet {
        let title = NSLocalizedString("signup_required_button")
        loginOrSignupButton.setTitle(title, for: .normal)
        loginOrSignupButton.setTitle(title, for: .highlighted)
  }

Ich kenne C # nicht, aber mit ein wenig Rätselraten denke ich, ich verstehe was

foo : int {
    get { return getFoo(); }
    set { setFoo(newValue); }
}

tut. Es sieht dem, was Sie in Swift haben, sehr ähnlich, aber es ist nicht dasselbe: In Swift haben Sie das getFoound nicht setFoo. Das ist kein kleiner Unterschied: Es bedeutet, dass Sie keinen zugrunde liegenden Speicher für Ihren Wert haben.

Swift hat Eigenschaften gespeichert und berechnet.

Eine berechnete Eigenschaft hat getund kann haben set(wenn es beschreibbar ist). Der Code im Getter und Setter muss dies jedoch in anderen Eigenschaften tun, wenn sie tatsächlich einige Daten speichern müssen . Es gibt keinen Hintergrundspeicher.

Eine gespeicherte Eigenschaft verfügt dagegen über einen Sicherungsspeicher. Aber es funktioniert nicht hat getund set. Stattdessen hat es willSetund didSetwas Sie verwenden können, um variable Änderungen zu beobachten und schließlich Nebenwirkungen auszulösen und / oder den gespeicherten Wert zu ändern. Sie haben willSetund didSetfür berechnete Eigenschaften nicht und Sie benötigen sie nicht, da Sie für berechnete Eigenschaften den Code verwenden können set, um Änderungen zu steuern.