Est-il possible d'autoriser didSet à être appelé lors de l'initialisation dans Swift?

Question

Les documents d'Apple spécifient que:

Les observateurs willSet et didSet ne sont pas appelés lors de la première initialisation d'une propriété. Ils sont uniquement appelés lorsque la valeur de la propriété est définie en dehors d'un contexte d'initialisation.

Est-il possible de forcer ces appels lors de l'initialisation?

Pourquoi?

Disons que j'ai cette classe

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

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

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

J'ai créé la méthode doStuffpour rendre les appels de traitement plus concis, mais je préfère simplement traiter la propriété dans la didSetfonction. Existe-t-il un moyen de forcer cet appel lors de l'initialisation?

Mettre à jour

J'ai décidé de supprimer l'intialiseur de commodité pour ma classe et de vous forcer à définir la propriété après l'initialisation. Cela me permet de savoir didSetsera toujours appelé. Je n'ai pas décidé si c'est mieux dans l'ensemble, mais cela convient bien à ma situation.

Créez une propre méthode set et utilisez-la dans votre méthode init:

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

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

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

En déclarant somePropertycomme type: AnyObject!(une option implicitement déballée), vous autorisez self à s'initialiser complètement sans somePropertyêtre défini. Lorsque vous appelez, setSomeProperty(someProperty)vous appelez un équivalent de self.setSomeProperty(someProperty). Normalement, vous ne seriez pas en mesure de le faire car self n'a pas été complètement initialisé. Puisque somePropertyne nécessite pas d'initialisation et que vous appelez une méthode dépendante de vous-même, Swift quitte le contexte d'initialisation et didSet s'exécutera.

Si vous utilisez l' deferintérieur d'un initialiseur , pour mettre à jour des propriétés facultatives ou pour mettre à jour des propriétés non facultatives que vous avez déjà initialisées et après avoir appelé des super.init()méthodes, votre willSet,didSet etc. sera appelée. Je trouve cela plus pratique que d'implémenter des méthodes distinctes que vous devez suivre pour appeler aux bons endroits.

Par exemple:

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

Donnera:

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

Comme variante de la réponse d'Oliver, vous pouvez envelopper les lignes dans une fermeture. Par exemple:

class Classy {

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

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

}

Edit: la réponse de Brian Westphal est à mon humble avis. La bonne chose à propos du sien est qu'il fait allusion à l'intention.

J'ai eu le même problème et cela fonctionne pour moi

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

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

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

Cela fonctionne si vous le faites dans une sous-classe

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

Par aexemple, didSetn'est pas déclenché. Mais dans l' bexemple, didSetest déclenché, car il est dans la sous-classe. Il doit faire quelque chose avec ce initialization contextqui signifie vraiment, dans ce cas, superclassil s'en est occupé

Bien que ce ne soit pas une solution, une autre façon de procéder serait d'utiliser un constructeur de classe:

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

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

Dans le cas particulier où vous souhaitez invoquer willSetou à l' didSetintérieur initpour une propriété disponible dans votre superclasse, vous pouvez simplement assigner directement votre super propriété:

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

Notez que la solution de Charlesisme avec une fermeture fonctionnerait toujours aussi dans ce cas. Ma solution n'est donc qu'une alternative.

Vous pouvez le résoudre de manière 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
    }
}