From Performance Wise: Class Computed Property vs Stored Property - ios

Question

So, I have this case where var3's value depends on both var1 and var2. Basically, this can be translated into two forms:
A) Using computed property for var3
class bla {
var var1: Int = 0
var var2: Int = 0
var var3: Int {
return var1 * var2
}
}
B) Using stored property with property observers for both var1 and var2
class bla {
var var1: Int = 0 {
didSet {
var3 = var1 * var2
}
}
var var2: Int = 0 {
didSet {
var3 = var1 * var2
}
}
var var3: Int = 0
}
However, in my case where I have to handle this, the variables are all parts of a huge model object that is being used inside a UITableViewCell. Being used in such context, it really needs to be as efficient as possible, which is the reason I'm trying to stay away from using computed properties for such case.. cause as I understand, when Swift get var3's value under A class implementation, it will compute its value on-the-fly, rather than get it cached like the way with B class implementation. Right? (Does Swift cache computed property's values in any way?)
Now I am really wondering what the best approach one should go with. In fact, the whole point I migrated some of those variables into the model object rather than computing them on-the-fly inside the cell, is to get the load off from the cell and get as much smooth scrolling as possible, which tells that using computed property makes my efforts meaningless. On the other hand, I came to cases where one of those variables depends on 3~4 other variables, which makes it necessary to re-compute it when each of those values get changed, which is also not efficient, I guess.
Any advices? Am I doing it wrong?

Answer 1

Here’s the approach I currently use where an instance property needs to be computed at some point and cached for subsequent accesses:
class AClassWithCachedInstanceVariables {
private var _var1: Var1Type?
var var1: Var1Type {
if let var1 = self._var1 {
// cache hit
return var1
} else {
// cache miss
let var1 = self.getVar1()
self._var1 = var1
return var1
}
}
private var _var2: Var2Type?
var var2: Var2Type {
if let var2 = self._var2 {
// cache hit
return var2
} else {
// cache miss
let var2 = self.getVar2()
self._var2 = var2
return var2
}
}
/* Extra: let’s say we also want to require var1 and var2
to be recomputed whenever this other variable is changed */
var otherVar: OtherVarType? {
didSet(oldOtherVar) {
if otherVar != oldOtherVar {
self._var1 = nil
self._var2 = nil
}
}
}
private func getVar1() -> Var1Type {
// compute stuff...
return Var1Type()
}
private func getVar2() -> Var2Type {
// compute stuff...
return Var2Type()
}
}