What is the correct way to define a constant value in a derived class used to validate parameters in a parent constructor in C#

Question

What is the correct way to define a constant value within a derived class in order to validate a parameter in the parent constructor.

Given the following example:

public abstract class Polygon
{
    protected abstract int VertexCount { get; }
    public LineSegment[] Edges { get { /* ... */ } }
    public Point2D[] Vertices { get { /* ... */ } }

    protected Polygon(Point2D vertices)
    {
        if(vertices.Length != VertexCount)
            threw new ArgumentOutOfRangeException(...);
    } 
}

public class Triangle: Polygon
{
    protected override int VertexCount { get; } = 3;
    public Triangle(Point2D[] vertices) : base(vertices){}
}

public class Quadrilateral: Polygon
{
    protected override int VertexCount { get; } = 4;
    public Quadrilateral(Point2D[] vertices) : base(vertices){}
}

Obviously the above does not work as expected due to the Virtual member call in constructor (yes I understand the warning, I'm not asking about that)

In my logic (which seems to be flawed), the VertexCount is a feature of the Polygon class (because the fixed size of the arrays of both Edges and Vertices will be defined by within the Polygon class) during initialization, and varies based on the derived class (hence needs to be defined in the derived class).

The derived class NEEDS to define the value of VertexCount because it is specific to the derived class, however, the base class isn't aware of the derived class. This is the reason for the 'abstract int', to ensure that the derived class overrides it. Also, VertexCount is a property, because fields cannot be abstract. However, it also should be a constant (because a triangle's sides are always going to be 3 and a quadrilateral's sides are always going to be 4).

Finally, the message for the Exception being thrown in the base constructor, should be something like:

if(vertices.Length != VertexCount)
    threw new ArgumentOutOfRangeException(nameof(vertices),
        message: $"A {this.ToString()} requires exactly {VertexCount} vertices, received {vertices.Length}");

Of course the 'this.ToString()' part would be called in the context of the base class rather than the derived class (maybe a reflection solution would work here)?

So with all of this, the alternative is to ditch the constructor in the base class, create a constant for the VertexCount in the derived classes, and initialize and set all the values in the derived classes constructors. This seems like it would be a lot of duplicated code across the derived classes (maybe not in the above example because technically I'm only duplicating 2 lines of code in each, but what happens when the constructor becomes heavier).

What is the 'proper' way of doing this with the least amount of duplicated code?

Answer 1

After re-reading Peter Duniho's comments I came up with this refactoring which I believe is a much better solution. (I think the wording of the question was a little ambiguous/subjective because the logic was off initially and I was looking for a correction to my logic as opposed to knowing exactly what the problem was and how to fix that problem)

The question:

What is the correct way to define a constant value in a derived class used to validate parameters in a parent constructor in C#

Short answer, you don't. Defining a constant in the above sample code is not necessary. It doesn't need to be stored at all, it is not something that other parts of the code (in this case) need, it is a value that is only needed for validation upon instantiation.

public class Triangle: Polygon
{
    public Triangle(Point2D[] vertices) : base(vertices, 3){}
}

public class Quadrilateral: Polygon
{
    public Quadrilateral(Point2D[] vertices) : base(vertices, 4){}
}

The other goal that I was trying to accomplish (with the original example), was early validation. In other words, if the correct number of vertices is not passed for the derived type, I want to stop initialization before any other initialization steps are performed on an invalid object. In the given example, an empty default constructor and validation within the derived constructor (or even a call to a validation method contained in the base method from the derived constructor) would be fine, not passing the vertices to the base, rather validating and then setting them in the derived constructor. However, the key is early validation, what if the base class does a bunch of stuff (a more complex class) to (pre)initialize the object before getting to the derived class. Validation code really belongs before any processing (including initialization).

By passing a (validation related) value to the base constructor allows the validation to occur at the beginning, so as to prevent other code from running if the validation fails.

protected Polygon(Point2D[] vertices, int expectedVerticesCount)
{
    // Don't bother initializing the object, the data is invalid!
    if(vertices.Length != expectedVerticesCount)
        throw new ArgumentOutOfRangeException( /* ... */);

    // The data is valid, proceed with initialization
    Vertices = vertices;
}