Ist es möglich, dass didSet während der Initialisierung in Swift aufgerufen wird?

Frage

In den Apple-Dokumenten wird Folgendes angegeben:

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.

Ist es möglich, diese während der Initialisierung aufzurufen?

Warum?

Nehmen wir an, ich habe diese Klasse

class SomeClass {
    var someProperty: AnyObject {
        didSet {
            doStuff()
        }
    }

    init(someProperty: AnyObject) {
        self.someProperty = someProperty
        doStuff()
    }

    func doStuff() {
        // do stuff now that someProperty is set
    }
}

Ich habe die Methode erstellt doStuff, um die Verarbeitungsaufrufe präziser zu gestalten, aber ich möchte lieber nur die Eigenschaft innerhalb der didSetFunktion verarbeiten. Gibt es eine Möglichkeit, diesen Aufruf während der Initialisierung zu erzwingen?

Aktualisieren

Ich habe beschlossen, nur den Convenience-Intializer für meine Klasse zu entfernen und Sie zu zwingen, die Eigenschaft nach der Initialisierung festzulegen. Dadurch kann ich wissen, didSetdass immer aufgerufen wird. Ich habe nicht entschieden, ob dies insgesamt besser ist, aber es passt gut zu meiner Situation.

Erstellen Sie eine eigene Set-Methode und verwenden Sie diese in Ihrer Init-Methode:

class SomeClass {
    var someProperty: AnyObject! {
        didSet {
            //do some Stuff
        }
    }

    init(someProperty: AnyObject) {
        setSomeProperty(someProperty)
    }

    func setSomeProperty(newValue:AnyObject) {
        self.someProperty = newValue
    }
}

Indem Sie somePropertyals Typ deklarieren : AnyObject!(ein implizit entpacktes optionales Element), können Sie sich selbst vollständig initialisieren, ohne somePropertyfestgelegt zu werden. Wenn Sie anrufen, rufen setSomeProperty(someProperty)Sie ein Äquivalent von an self.setSomeProperty(someProperty). Normalerweise können Sie dies nicht tun, da self nicht vollständig initialisiert wurde. Da somePropertykeine Initialisierung erforderlich ist und Sie eine von self abhängige Methode aufrufen, verlässt Swift den Initialisierungskontext und didSet wird ausgeführt.

Wenn Sie deferinnerhalb eines initializer , für die Aktualisierung aller optionalen Eigenschaften oder ein weitere Aktualisierung nicht-optionale Eigenschaften , dass Sie bereits initialisiert haben und nach haben Sie genannt super.init()Methoden, dann willSet, didSetusw. genannt werden. Ich finde das bequemer als die Implementierung separater Methoden, mit denen Sie den Anruf an den richtigen Stellen verfolgen können.

Beispielsweise:

public class MyNewType: NSObject {

    public var myRequiredField:Int

    public var myOptionalField:Float? {
        willSet {
            if let newValue = newValue {
                print("I'm going to change to \(newValue)")
            }
        }
        didSet {
            if let myOptionalField = self.myOptionalField {
                print("Now I'm \(myOptionalField)")
            }
        }
    }

    override public init() {
        self.myRequiredField = 1

        super.init()

        // Non-defered
        self.myOptionalField = 6.28

        // Defered
        defer {
            self.myOptionalField = 3.14
        }
    }
}

Wird ergeben:

I'm going to change to 3.14
Now I'm 3.14

Als Variation von Olivers Antwort könnten Sie die Zeilen in einen Verschluss einwickeln. Z.B:

class Classy {

    var foo: Int! { didSet { doStuff() } }

    init( foo: Int ) {
        // closure invokes didSet
        ({ self.foo = foo })()
    }

}

Edit: Brian Westphals Antwort ist imho schöner. Das Schöne an ihm ist, dass es auf die Absicht hinweist.

Ich hatte das gleiche Problem und das funktioniert bei mir

class SomeClass {
    var someProperty: AnyObject {
        didSet {
            doStuff()
        }
    }

    init(someProperty: AnyObject) {
        defer { self.someProperty = someProperty }
    }

    func doStuff() {
        // do stuff now that someProperty is set
    }
}

Dies funktioniert, wenn Sie dies in einer Unterklasse tun

class Base {

  var someProperty: AnyObject {
    didSet {
      doStuff()
    }
  }

  required init() {
    someProperty = "hello"
  }

  func doStuff() {
    print(someProperty)
  }
}

class SomeClass: Base {

  required init() {
    super.init()

    someProperty = "hello"
  }
}

let a = Base()
let b = SomeClass()

Wird abeispielsweise didSetnicht ausgelöst. Wird aber zum bBeispiel didSetausgelöst, weil es in der Unterklasse ist. Es hat etwas mit dem zu tun, was initialization contextwirklich bedeutet, in diesem Fall hat sich das superclassdarum gekümmert

Dies ist zwar keine Lösung, aber eine alternative Vorgehensweise wäre die Verwendung eines Klassenkonstruktors:

class SomeClass {
    var someProperty: AnyObject {
        didSet {
            // do stuff
        }
    }

    class func createInstance(someProperty: AnyObject) -> SomeClass {
        let instance = SomeClass() 
        instance.someProperty = someProperty
        return instance
    }  
}

In dem speziellen Fall, in dem Sie eine in Ihrer Oberklasse verfügbare Eigenschaft aufrufen willSetoder didSetin diese aufnehmen möchten init, können Sie Ihre Super-Eigenschaft einfach direkt zuweisen:

override init(frame: CGRect) {
    super.init(frame: frame)
    // this will call `willSet` and `didSet`
    someProperty = super.someProperty
}

Beachten Sie, dass die Charlesism- Lösung mit einem Verschluss in diesem Fall immer auch funktionieren würde. Meine Lösung ist also nur eine Alternative.

Sie können es auf folgende Weise lösen:

class SomeClass {
    private var _someProperty: AnyObject!
    var someProperty: AnyObject{
        get{
            return _someProperty
        }
        set{
            _someProperty = newValue
            doStuff()
        }
    }
    init(someProperty: AnyObject) {
        self.someProperty = someProperty
        doStuff()
    }

    func doStuff() {
        // do stuff now that someProperty is set
    }
}