Czy można zezwolić na wywoływanie didSet podczas inicjalizacji w Swift?

Pytanie

Dokumenty Apple'a określają, że:

Obserwatory willSet i didSet nie są wywoływane przy pierwszej inicjalizacji właściwości. Są wywoływane tylko wtedy, gdy wartość właściwości jest ustawiona poza kontekstem inicjalizacji.

Czy można wymusić ich wywoływanie podczas inicjalizacji?

Czemu?

Powiedzmy, że mam tę klasę

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

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

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

Stworzyłem metodę doStuff, aby wywołania przetwarzania były bardziej zwięzłe, ale wolałbym po prostu przetworzyć właściwość w ramach didSetfunkcji. Czy istnieje sposób, aby zmusić to do wywołania podczas inicjalizacji?

Aktualizacja

Postanowiłem po prostu usunąć wygodny interializer dla mojej klasy i zmusić cię do ustawienia właściwości po inicjalizacji. To pozwala mi wiedzieć, didSetże zawsze będzie dzwonić. Nie zdecydowałem, czy jest to ogólnie lepsze, ale dobrze pasuje do mojej sytuacji.

Utwórz własną metodę zestawu i użyj jej w metodzie init:

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

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

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

Deklarując somePropertyjako typ: AnyObject!(domyślnie nieopakowane opcjonalne), pozwalasz sobie na pełną inicjalizację bez somePropertyustawiania. Kiedy dzwonisz setSomeProperty(someProperty), dzwonisz do równowartości self.setSomeProperty(someProperty). Zwykle nie byłbyś w stanie tego zrobić, ponieważ jaźń nie została w pełni zainicjowana. Ponieważ somePropertynie wymaga inicjalizacji, a ty wywołujesz metodę zależną od siebie, Swift opuszcza kontekst inicjalizacji i didSet uruchomi się.

Jeśli używasz deferwewnątrz z inicjatora , w celu aktualizacji opcjonalnych właściwości lub dalszej aktualizacji non-opcjonalne właściwości, które zostały już zainicjowane i po tym, jak nazywa się żadnych super.init()metod, wówczas willSet, didSetitp zostanie wywołana. Uważam, że jest to wygodniejsze niż wdrażanie osobnych metod, które musisz śledzić w odpowiednich miejscach.

Na przykład:

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

Przyniesie:

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

Jako wariant odpowiedzi Olivera możesz zawinąć linie w zamknięcie. Na przykład:

class Classy {

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

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

}

Edycja: Odpowiedź Briana Westphala jest ładniejsza imho. Zaletą jego jest to, że wskazuje to na intencję.

Miałem ten sam problem i to działa dla mnie

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

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

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

Działa to, jeśli zrobisz to w podklasie

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

Na aprzykład didSetnie jest wyzwalany. Ale na bprzykład didSetjest wyzwalany, ponieważ znajduje się w podklasie. To ma coś wspólnego z tym, co initialization contextnaprawdę oznacza, w tym przypadku o superclassto dbało

Chociaż nie jest to rozwiązanie, alternatywnym sposobem obejścia tego problemu byłoby użycie konstruktora klasy:

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

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

W szczególnym przypadku, w którym chcesz wywołać właściwość dostępną w nadklasie willSetlub didSetwewnątrz initniej, możesz po prostu przypisać swoją super właściwość bezpośrednio:

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

Zauważ, że rozwiązanie Charlesism z zamknięciem zawsze działałoby również w tym przypadku. Więc moje rozwiązanie jest tylko alternatywą.

Możesz to rozwiązać w obj-с sposób:

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