É possível permitir que didSet seja chamado durante a inicialização no Swift?

Questão

Os documentos da Apple especificam que:

Os observadores willSet e didSet não são chamados quando uma propriedade é inicializada. Eles são chamados apenas quando o valor da propriedade é definido fora de um contexto de inicialização.

É possível forçar que estes sejam chamados durante a inicialização?

Por quê?

Digamos que eu tenho essa aula

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

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

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

Criei o método doStuff, para tornar as chamadas de processamento mais concisas, mas prefiro apenas processar a propriedade dentro da didSetfunção. Existe uma maneira de forçar isso a chamar durante a inicialização?

Atualizar

Decidi remover o intializer de conveniência da minha classe e forçá-lo a definir a propriedade após a inicialização. Isso me permite saber didSetque sempre será chamado. Ainda não decidi se isso é melhor no geral, mas combina bem com minha situação.

Crie um método próprio e use-o dentro do seu método init:

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

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

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

Ao declarar somePropertycomo tipo: AnyObject!(um opcional implicitamente desembrulhado), você se inicializa totalmente sem somePropertyser definido. Quando você liga, setSomeProperty(someProperty)liga para o equivalente a self.setSomeProperty(someProperty). Normalmente você não seria capaz de fazer isso porque o self não foi totalmente inicializado. Como somePropertynão requer inicialização e você está chamando um método dependente de si, Swift sai do contexto de inicialização e o didSet será executado.

Se você usar deferdentro de um inicializador , para atualizar as propriedades opcionais ou ainda atualizar as propriedades não-opcionais que você já tenha inicializado e depois de você ter chamado quaisquer super.init()métodos, então o seu willSet, didSet, etc. será chamado. Acho isso mais conveniente do que implementar métodos separados, dos quais você precisa acompanhar as chamadas nos lugares certos.

Por exemplo:

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

Produzirá:

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

Como uma variação da resposta de Oliver, você pode encerrar as linhas em um fechamento. Por exemplo:

class Classy {

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

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

}

Edit: A resposta de Brian Westphal é melhor imho. O bom dele é que ele indica a intenção.

Eu tive o mesmo problema e isso funciona para mim

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

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

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

Isso funciona se você fizer isso em uma subclasse

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

No aexemplo, didSetnão é acionado. Mas, por bexemplo, didSeté acionado, porque está na subclasse. Tem a ver com o que initialization contextrealmente significa, neste caso, o superclassque importava com isso

Embora isso não seja uma solução, uma maneira alternativa de fazer isso seria usar um construtor de classe:

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

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

No caso específico em que você deseja chamar willSetou didSetentrar initpara uma propriedade disponível em sua superclasse, você pode simplesmente atribuir sua super propriedade diretamente:

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

Observe que a solução do Charlesismo com um fechamento sempre funcionaria também nesse caso. Então, minha solução é apenas uma alternativa.

Você pode resolvê-lo de maneira objetiva:

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