Question

I have the following classes:

public abstract class BaseClass
{
    private readonly double cachedValue;

    public BaseClass()
    {
         cachedValue = ComputeValue();
    }

    protected abstract double ComputeValue()          
}


public class ClassA : BaseClass
{
    protected override double ComputeValue()  { ... }            
}

public class ClassB : BaseClass
{
    protected override double ComputeValue()  { ... }                
}

where ComputeValue() is a time consuming computation.

Problem is, there are other methods in the ClassA and ClassB which require the value returned from ComputeValue(). I was thinking of adding a protected property named ‘CachedValue’ in BaseClass but I find this approach to be redundant and confusing to other programmers who might not be aware of its existence, and might call ComputeValue() directly.

The second option is to use nullable type at the derived class level as I don’t necessarily require the computation to be done in the constructor in BaseClass, lazy computation might be a better option:

protected override double ComputeValue()  
{
    if(cachedValue.HasValue)
    {
        return (double) cachedValue;
    }

    // Do computation
    cachedValue = ...

    return cachedValue;
}        

but I feel I could do better.

What are your thoughts on this ?

Thank you.

Edit: Just to clarify, I’m trying to prevent ComputeValue() from getting called more than once by enforcing the use of ‘cachedValue‘.

Answer 1

Another approach would be to add a public interface method GetValue on the Baseclass and only allow to overwrite the ComputeValue method for inherited classes – this way you can still extend the functionality, but you control the behavior/context of the result of ComputeValue in your base class, i.e. you can add memoization like in the example or decorate/extend as needed.

This follows the Non-Virtual interface (NVI) pattern .

    public abstract class BaseClass
    {
        private double? cachedValue;

        public BaseClass()
        {
        }

        protected abstract double ComputeValue();

        public virtual double GetValue()
        {
            if (cachedValue.HasValue)
            {
                return (double)cachedValue;
            }
            else
            {
                cachedValue = ComputeValue();
                return (double)cachedValue;
            }

        }
    }