Default constructor unnecessarily initializing dependency when not required

Question

I have two types, i.e AdditionCalc and AggregateCalc which have two methods:

1. Calculate: Returns Model. No version code.
2. Calculate: Doesn't return anything. Includes Versioning code. Stores the data in database.

Code :

public abstract class BaseCalculator 
{
     private readonly IVersion _version;
     protected BaseCalculator(IVersion version)
     {
            this._version = version;
     }
     public void Calculate(Request r)
     {
          CalculateInternal();
          //version code here
     }
     protected abstract void CalculateInternal(Request r);
     public abstract StatisticsModel Calculate(StatisticsRequest model);
}

public class AdditionCalc : BaseCalculator
{
    public AdditionCalc() : base(new Version(ConfigurationManager.ConnectionStrings["dbConnectionString"].ConnectionString)) { }
    public override StatisticsModel Calculate(StatisticsRequest model)
    {
         //no version code here
    }
}

public class CalculatorFactory
{
    public BaseCalculator GetCalculatorByType(int type)
    {
        switch (type)
        {
            case (int)Types.Addition:
                return new AdditionCalc();
            case (int)Types.Aggregate:
                return new AggregateCalc();
        }
    }
}

Now the problem is when I call Calculate method which returns StatisticsModel, I don't want to call base constructor because for this method I don't require version code, but every time when I call this method, the default constructor gets called and it initializes the version variable of base class.

This is how I am calling the appropriate Calculate method:

var calculatorFactory = new CalculatorFactory();
var type = calculatorFactory.GetCalculatorByType((int)Types.Addition);
type.Calculate(StatisticsRequest);

Note: I don't want to pass version dependency from calling code.

So how do I design the above code so that Version code doesn't get called for Calculate method which returns StatisticsModel?

Update :

public class AdditionCalc : BaseCalculator
{
    public AdditionCalc() : base(new Version(ConfigurationManager.ConnectionStrings["dbConnectionString"].ConnectionString)) { }
    public override StatisticsModel Calculate(StatisticsRequest model)
    {
         //no version code here
    }
    protected override void CalculateInternal(Request r)
    {
    }
}

public class AggregateCalc : BaseCalculator
{
    public AggregateCalc() : base(new Version(ConfigurationManager.ConnectionStrings["dbConnectionString"].ConnectionString)) { }
    public override StatisticsModel Calculate(StatisticsRequest model)
    {
         //no version code here
    }
    protected override void CalculateInternal(Request r)
    {
    }
}

Answer 1

Your two calculator classes should not be related to each other. They should implement a common interface, but share no common logic.

So you'd have one class that supports the versioning stuff, and one that doesn't know anything about versioning. Each is 100% focused on its own logic and neither have to be coupled/related to or interact with the other.

If you later do have some common behavior make sure it is indeed common behavior and put it in a base class that both of your classes inherit.

As you have it now, you're overriding the versioning behavior (and not even completely). When you are using inheritance, you want to add capabilities, not subtract them, which is kind of what your current model is doing.

Take a look at SOLID for some further guidance.

Consider,

interface ICalculator
{
    void Calculate() { ... }
}

abstract class CalculatorThatCaresAboutVersion : ICalculator
{
    void CalculatorThatCaresAboutVersion(IVersion version) { ... }
}

abstract class CalculatorThatDoesntCareAboutVersion : ICalculator
{
    void CalculatorThatDoesntCareAboutVersion() { ... }
}

You have two kinds of calculators that don't know or care about the other kinds. You can inherit from them if you need to, and the operation(s) associated with version don't have anything to do with the operation(s) in the other calculators.

That gives you the freedom to implement each as needed without affecting the other: no questions like "well how do I not initialize version if I don't care about it?" Because there's a natural separation of concerns, the question never even arises.

Answer 2

If I'm not wrong, you need version only for Calculate(Request r) and not for Calculate(StatisticsRequest model)

Also you are ok with hiding the dependency in the class you are using, i.e. you don't want the client code to pass the version (which may not be a good idea).

What about removing the IVersion parameter for BaseCalculator and retrieve the value you need in the Calculate method? Something like this:

public abstract class BaseCalculator 
{
    private readonly IVersion _version;
    protected BaseCalculator()
    {
    }

    public void Calculate(Request r)
    {
        this._version = GetVersion();
        CalculateInternal();
        //version code here
    }
    protected virtual void GetVersion() //protected virtual or abstract, pick the best for your scenario.
    {
        return new Version(ConfigurationManager.ConnectionStrings["dbConnectionString"].ConnectionString);
    }

    protected abstract void CalculateInternal(Request r);
    public abstract StatisticsModel Calculate(StatisticsRequest model);
}

The protected GetVersion method can be overridden in the derived classes (or can be an abstract method if your BaseCalculator doesn't know how to create the Version object, forcing derived classes to supply an implementation).

Answer 3

What you are explaining sounds like optional dependency.

One way to resolve it without significantly changing the design is to defer IVersion creation to the point when it's really needed by replacing the IVersion constructor argument with some sort of a factory - for instance Func<IVersion>, and eventually combine it with Lazy<T> field if it needs to create just once.

e.g. something like this:

public abstract class BaseCalculator 
{
    private readonly Func<IVersion> _versionFactory;
    protected BaseCalculator(Func<IVersion> versionFactory)
    {
        _versionFactory = versionFactory;
    }
}    

and inside the method(s) which needs IVersion

var version = _versionFactory();
// version code here

or

public abstract class BaseCalculator 
{
    private readonly Lazy<IVersion> _version;
    protected BaseCalculator(Func<IVersion> versionFactory)
    {
        _version = new Lazy<IVersion>(versionFactory);
    }
}    

and

var version = _version.Value;
// version code here

In both cases the derived class constructor code would be something like this (just add () => before the current base call code):

public AdditionCalc() : base(() => new Version(ConfigurationManager.ConnectionStrings["dbConnectionString"].ConnectionString)) { }

Answer 4

What you want to accomlish would require overriding the base constructor which cannot be done, see this post.