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

On 2/22/21 2:00 PM, Jack wrote:

>      C defValue() { return C.a; }

Yes, putting the expression in a function is the way I know for lazy evaluation.

Ali