È possibile consentire a didSet di essere chiamato durante l'inizializzazione in Swift?

Domanda

I documenti di Apple specificano che:

Gli osservatori willSet e didSet non vengono chiamati quando una proprietà viene inizializzata per la prima volta. Vengono chiamati solo quando il valore della proprietà è impostato al di fuori di un contesto di inizializzazione.

È possibile forzare la loro chiamata durante l'inizializzazione?

Perché?

Diciamo che ho questa lezione

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

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

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

Ho creato il metodo doStuff, per rendere le chiamate di elaborazione più concise, ma preferirei semplicemente elaborare la proprietà all'interno della didSetfunzione. C'è un modo per forzare questo a chiamare durante l'inizializzazione?

Aggiornare

Ho deciso di rimuovere semplicemente l'intializer di convenienza per la mia classe e costringerti a impostare la proprietà dopo l'inizializzazione. Questo mi permette di sapere che didSetverrà sempre chiamato. Non ho deciso se nel complesso sia meglio, ma si adatta bene alla mia situazione.

Crea un tuo set-Method e usalo nel tuo init-Method:

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

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

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

Dichiarando somePropertycome tipo: AnyObject!(un'opzione implicitamente non scartata), si consente a sé di inizializzare completamente senza somePropertyessere impostato. Quando chiami setSomeProperty(someProperty), chiami un equivalente di self.setSomeProperty(someProperty). Normalmente non saresti in grado di farlo perché il sé non è stato completamente inizializzato. Poiché somePropertynon richiede l'inizializzazione e stai chiamando un metodo dipendente da sé, Swift lascia il contesto di inizializzazione e didSet verrà eseguito.

Se si utilizza deferall'interno di un inizializzatore , per aggiornare le proprietà opzionali o ulteriore aggiornamento proprietà non opzionali che hai già inizializzato e dopo aver chiamato tutti i super.init()metodi, allora il vostro willSet, didSete così via si chiamerà. Trovo che questo sia più conveniente dell'implementazione di metodi separati che devi tenere traccia delle chiamate nei posti giusti.

Per esempio:

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
        }
    }
}

Produrrà:

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

Come variante della risposta di Oliver, potresti avvolgere le linee in una chiusura. Per esempio:

class Classy {

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

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

}

Modifica: la risposta di Brian Westphal è più bella. La cosa bella della sua è che accenna all'intenzione.

Ho avuto lo stesso problema e questo funziona per me

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

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

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

Funziona se lo fai in una sottoclasse

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()

Ad aesempio, didSetnon viene attivato. Ma ad besempio, didSetviene attivato perché si trova nella sottoclasse. Deve fare qualcosa con ciò che initialization contextrealmente significa, in questo caso superclassse ne preoccupava

Anche se questa non è una soluzione, un modo alternativo per farlo sarebbe usare un costruttore di classi:

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

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

Nel caso particolare in cui desideri invocare willSeto didSetall'interno initdi una proprietà disponibile nella tua superclasse, puoi semplicemente assegnare direttamente la tua super proprietà:

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

Si noti che la soluzione di Charlesism con una chiusura funzionerebbe sempre anche in quel caso. Quindi la mia soluzione è solo un'alternativa.

Puoi risolverlo in modo oggettivo:

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
    }
}