I have a base class that loads a value and if it isn't net, load
a default value. Since the value can be set, I'd like to do lazy
evaluation of this default value until it's really needed. So
rather have a C defValue = xxx, that makes xxx to be loaded even
if defValue doesn't get used. So I thought I would use property
and override it from the derived class, to archive the lazy
evaluation effect that I'd like. Is this a good approach? are
there better ways to do that? here's a sample code of what I'm
talking about (I'm using int just to make it simple but the class
in the real code is bigger and can have many instances, hence my
attempt to optimize that):
class A
{
C defValue() { return C.a; }
C value;
void doSomething()
{
// doSomething gets called from all derived classes
// but value is set often, loading defValue right
away
// would waste time and resources
if(!value) {
value = defValue;
}
}
}
class B : A
{
// use propety to have a lazy evaluation of value
override C defValue() { return C.b; }
void foo()
{
// loadDefvalue, if value not set, lazily...
doSomething();
// do something else...
}
}
class C
{
int n;
this(int v)
{
n = v;
}
static this()
{
a = new C(10);
b = new C(11);
}
void load()
{
// do something with n
}
static
{
C a;
C b;
}
}