NSOperation property overrides (isExecuting / isFinished) NSOperation property overrides (isExecuting / isFinished) ios ios

NSOperation property overrides (isExecuting / isFinished)


As David said, you can implement both a getter and setter in the subclass property override.

But, when defining asynchronous/concurrent operations (i.e. those operations that will complete asynchronously), it is critical to call the will/didChangeValueForKey for isFinished and isExecuting. If you don't, operations won't be released, dependencies won't be honored, you'll have problems is maxConcurrentOperationCount, etc.).

So I would therefore suggest:

private var _executing: Bool = falseoverride var executing: Bool {    get {        return _executing    }    set {        if _executing != newValue {            willChangeValueForKey("isExecuting")            _executing = newValue            didChangeValueForKey("isExecuting")        }    }}private var _finished: Bool = false;override var finished: Bool {    get {        return _finished    }    set {        if _finished != newValue {            willChangeValueForKey("isFinished")            _finished = newValue            didChangeValueForKey("isFinished")        }    }}

By the way, checking to see if _executing and _finished have changed is not critical, but it can sometimes be useful when writing custom cancel methods or the like.


Update:

More than once, people have pointed to the new finished/executing properties in NSOperation.h and concluded that the appropriate KVO keys would be finished/executing. Generally, when writing KVO-compliant properties, that would be correct.

But NSOperationQueue does not observe the finished/executing keys. It observes the isFinished/isExecuting keys. If you don't perform the KVO calls for the isFinished/isExecuting keys, you can have problems (notably dependencies between asynchronous operations will fail). It's annoying, but that's how it works. The Configuring Operations for Concurrent Execution section of the Operation Queues chapter of the Concurrency Programming Guide is very clear on the topic of needing to perform the isFinished/isExecuting KVO calls.

While the Concurrency Programming Guide is dated, it's quite explicit regarding the isFinished/isExecuting KVO. And one can easily empirically validate that the guide still reflects the actual NSOperation implementation. By way of demonstration, see the unit tests in this Github demonstration of the appropriate KVO when using asynchronous/concurrent NSOperation subclass in NSOperationQueue.


From the swift book:

You can present an inherited read-only property as a read-write property by providing both a getter and a setter in your subclass property override.

I think you'll find that this works:

override var executing : Bool {    get { return _executing }    set {         willChangeValueForKey("isExecuting")        _executing = newValue         didChangeValueForKey("isExecuting")    }}private var _executing : Bool


Swift 3.0 Answer Update:

private var _executing : Bool = falseoverride var isExecuting : Bool {    get { return _executing }    set {        guard _executing != newValue else { return }        willChangeValue(forKey: "isExecuting")        _executing = newValue        didChangeValue(forKey: "isExecuting")    }}private var _finished : Bool = falseoverride var isFinished : Bool {    get { return _finished }    set {        guard _finished != newValue else { return }        willChangeValue(forKey: "isFinished")        _finished = newValue        didChangeValue(forKey: "isFinished")    }}


matomo