¿Es posible permitir que se llame a didSet durante la inicialización en Swift?

Pregunta

Los documentos de Apple especifican que:

Los observadores willSet y didSet no son llamados cuando una propiedad se inicializa por primera vez. Solo se llaman cuando el valor de la propiedad se establece fuera de un contexto de inicialización.

¿Es posible forzar que se invoquen estos durante la inicialización?

¿Por qué?

Digamos que tengo esta clase

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

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

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

Creé el método doStuffpara hacer que las llamadas de procesamiento sean más concisas, pero prefiero simplemente procesar la propiedad dentro de la didSetfunción. ¿Hay alguna manera de forzar esto a llamar durante la inicialización?

Actualizar

Decidí eliminar el intializador de conveniencia para mi clase y forzarlo a configurar la propiedad después de la inicialización. Esto me permite saber didSetque siempre se llamará. No he decidido si esto es mejor en general, pero se adapta bien a mi situación.

Cree un método set propio y úselo dentro de su método init:

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

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

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

Al declarar somePropertycomo tipo: AnyObject!(una opción implícitamente desenvuelta), se permite que se inicialice completamente sin somePropertyestar configurado. Cuando llamas setSomeProperty(someProperty)estás llamando a un equivalente de self.setSomeProperty(someProperty). Normalmente no podría hacer esto porque self no se ha inicializado por completo. Como somePropertyno requiere inicialización y está llamando a un método dependiente de sí mismo, Swift deja el contexto de inicialización y didSet se ejecutará.

Si se utiliza deferdentro de un inicializador , para la actualización de las propiedades opcionales o más propiedades de actualización no opcionales que ya ha inicializado y después de que ha llamado a ningún super.init()métodos, a continuación, su willSet, didSetetc. será llamado. Creo que esto es más conveniente que implementar métodos separados que tiene que hacer un seguimiento de las llamadas en los lugares correctos.

Por ejemplo:

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

Rendirá:

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

Como una variación de la respuesta de Oliver, podría ajustar las líneas en un cierre. P.ej:

class Classy {

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

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

}

Editar: la respuesta de Brian Westphal es mejor en mi humilde opinión. Lo bueno de él es que insinúa la intención.

Tuve el mismo problema y esto funciona para mí.

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

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

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

Esto funciona si haces esto en una subclase

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

Por aejemplo, didSetno se activa. Pero, por bejemplo, didSetse dispara, porque está en la subclase. Tiene que ver con lo que initialization contextrealmente significa, en este caso, eso superclasssí le importó

Si bien esto no es una solución, una forma alternativa de hacerlo sería usar un constructor de clases:

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

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

En el caso particular en el que desea invocar willSeto didSetdentro initde una propiedad disponible en su superclase, simplemente puede asignar su súper propiedad directamente:

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

Tenga en cuenta que la solución de carlosismo con un cierre siempre funcionaría también en ese caso. Entonces mi solución es solo una alternativa.

Puedes resolverlo de forma obj-с:

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