类构造函数应该只用于依赖注入吗？

Question

There are two major ways that class constructors can populate their class' dependencies:

1. Populate the class dependencies by constructor dependency injection.
2. Populate the class dependencies by using the constructor parameters to run some calculations in the constructor. The dependencies are instantiated based on the calculation results. This may involve use of new .

I am wondering if the second method adheres to good coding practices such as the Single Responsibility Principle, and if that sort of functionality really belongs in a class constructor. It seems convenient, but I am not sure if it is a good idea.

Here's an example of what I mean:

public class VectorSpace
{
    // This class depends on an array of Vectors.
    Vector[] spanningSet;

    // 1. Populate the class dependencies by constructor dependency injection.
    public VectorSpace(Vector[] spanningSet)
    {
        this.spanningSet = spanningSet;
    }

    // 2. Populate the class dependencies by running some calculations in the constructor.
    public VectorSpace(Rect rectangle, int numberOfCellsX, int numberOfCellsY)
    {
        // Construct this class to make sure the resulting vector space fits the given rectangle, forming a grid.
        // Some calculations that ultimately populate the class dependencies go here...
    }

    // Public methods for performing calculations using the Vectors go here...
}

It feels odd because making the vector space fill a grid feels like a job that is outside the scope of this class, but I don't know where else I would define this second constructor.

Is the functionality of the second constructor appropriate to be in this class? If not, where would I move this constructor body to? Should I use a static factory method instead? Should I make this constructor be the constructor of a different class? Maybe I could have a similar method somewhere that returns an array of Vectors that I could pass into the dependency injection constructor, but where would I define that method?

Answer 1

VectorSpace class depends on the data (set of vectors), but data can be provided/calculated in many ways.
Will logic of VectorSpace change if you will change how vectors should be calculated/retrieved? I assume not - so it is shouldn't be part of the VectorSpace class.

We can create dedicated class which will be responsible to calculate required data.

public class SpanningSetFactory
{
    public Vector[] Create(Rect rectangle, int numberOfCellsX, int numberOfCellsY)
    {
        // Calculate and return set of vectors
    }
}

Now VectorSpace can explicitly "tell" other developers/readers that it depends only on the set of vectors

public class VectorSpace
{
    public VectorSpace(Vector[] spanningSet) => _spanningSet = spanningSet
}

Now both logics "Calculate spanning set" and "Use spanning set" will be in their own locations without dependency on each other - only dependency link they have with each other will be array of Vector

I would suggest to avoid putting some calculations(especially heavy ones) in the constructor.
Good help for other developers will be when critical logic(calculations, data retrieving) is explicitly visible in forms of methods or other types.