Question

Let’s suppose that we have 3 classes: Base, Root and Child.

public abstract class Base
{
    protected int _Value;

    public double DoSomeWork(int value)
    {
        _Value = value;
        double result = Calculate();

        return result;
    }

    public abstract double Calculate();

    public Child CreateChild(int length)
    {
        return new Child(this);
    }
}

public class Root : Base
{
    public override double Calculate()
    {
        return _Value;
    }
}

public class Child : Base
{
    readonly Base _Container;

    public Child(Base container)
    {
        _Container = container;
    }

    public override double Calculate()
    {
        double result = _Container.Calculate();
        // do some more calculation

        return result;
    }
}

My issue here is that I would like only the DoSomeWork (and CreateChild) be publicly accessible, but in my “architecture” I am forced to make Calculate public also. Or am I?

Any input will be very much appreciated.

Edit:

Calculate cannot be protected because of this line in Child

double result = _Container.Calculate();

which would cause a build error to occur.

Answer 1

No, you can make it protected. That way your derived class will still have access to it and be able to override it, but it won’t be allowed publicly.

Good thinking, this is exactly the way to do it: override as little as possible and hide as much as possible.

– Edit –

Since this is probably a simplified example of what you are actually doing, I can only provide a guess to what these methods do, but here it goes.

I have a feeling that Calculate method might not belong to your Base class. It looks like it provides an auxiliary calculation result used by DoSomeWork. Inheritance is usually used when your base class has some common calculation to “offer” to derived classes, so that you don’t have to repeat yourself.

For example, let’s say that your DoSomeWork method has some certain functionality that doesn’t change, but requires an “external” calculation to be performed first. If you started by creating a simple separate interface for the external calculation:

interface ICalculator
{
    double Calculate();
}

You could define different implementations of this interface. You can start by creating a simple implementation (similar to your Root functionality):

class SimpleCalculator : ICalculator
{
    readonly double _value;
    public SimpleCalculator(double value)
    {
       _value = value;
    }

    public double Calculate()
    {
       return _value;
    }
}

And you could also easily wrap existing implementations inside more complex classes (similar to what CreateChild intends to do):

// for the rest of the world, this is an ICalculator like any other
class CalculatorWrapper : ICalculator
{ 
    readonly ICalculator _base;
    public CalculatorWrapper(ICalculator baseCalc)
    {
       _base = baseCalc;
    }

    public double Calculate()
    {
       double value = _base.Value; 
       return 2 * value;
    }
}

And then, your actual class needs to use this functionality to some intended “extra work”:

interface MyWorker
{
    double DoSomeWork(int value);
}

class YourClass
{
    readonly ICalculator _calc; 
    readonly double _someOtherValue;

    public YourClass(ICalculator calc, double someOtherValue)
    {
       _calc = calc;
       _someOtherValue = someOtherValue;
    }

    public double DoSomeWork(int value)
    {
       // use whatever you get from your calc
       double externalValue = _calc.Calculate();

       // and do some "actual work"
       return _someOtherValue + value + externalValue;
    }
}

Or, you could pass the “calculator” to DoSomeWork on each call, as a parameter, and change the complex class to something like:

interface MyWorker
{
    double DoSomeWork(ICalculator calc, int value);
}

class YourClass
{
    public double DoSomeWork(ICalculator calc, int value)
    {
       // use whatever you get from your calc
       double externalValue = calc.Calculate();

       // and do some "actual work"
       return _someOtherValue + value;
    }
}