Constructor restrictions

Question

i was wondering if there is a way to restrict a value in construction. Here is my code :

class Student : Human 
{
    private double Grade;

    public Student(string FirstName, string LastName, double Grade)
        : base(FirstName, LastName)
    {
        this.FirstName = FirstName;
        this.LastName = LastName;
        this.Grade = Grade;
    }
}

and when i make a new Student i want to restrict the Grade between >= 2.00 and <= 6.00 , like compile error or excepion on runtime. Is there a way ? (Don't worry about other fields FirstName, and LastName)

Answer 1

You can check it and throw an exception at runtime, like this:

if (grade < 2.00 || grade > 6.00)
    throw new ArgumentOutOfRangeException("grade");

Always put such conditions at the start of the method or constructor. I even put them in their own #region (but that's my personal preference):

public Student(string firstName, string lastName, double grade)
    : base(firstName, lastName)
{
    #region Contract
    if (grade < 2.00 || grade > 6.00)
        throw new ArgumentOutOfRangeException("grade");
    #endregion
    this.FirstName = firstName;
    this.LastName = lastName;
    this.Grade = grade;
}

However, there is a way to get compile-time warnings for such things using Code Contracts. You can download Code Contracts on MSDN and there you can also find the documentation. It only integrates with non-Express versions of Visual Studio and is written by Microsoft. It will check whether method calls are likely to adhere to the contract you specify. Your code would then become:

using System.Diagnotistics.Contracts;

public Student(string firstName, string lastName, double grade)
    : base(firstName, lastName)
{
    #region Contract
    Contract.Requires<ArgumentOutOfRangeException>(grade >= 2.00);
    Contract.Requires<ArgumentOutOfRangeException>(grade <= 6.00);
    #endregion
    this.FirstName = firstName;
    this.LastName = lastName;
    this.Grade = grade;
}

Answer 2

You can thrown an exception:

class Student : Human 
{
    private double Grade;

    public Student(string FirstName, string LastName, double Grade)
        : base(FirstName, LastName)
    {
        if (Grade >= 2 && Grade <= 6) { 
          throw new ArgumentOutOfRangeException();
        }

        this.FirstName = FirstName;
        this.LastName = LastName;
        this.Grade = Grade;
    }
}

If you're using Microsoft Code Contracts you can do it this was as well:

class Student : Human  {
    private double Grade;

    public Student(string FirstName, string LastName, double Grade)
        : base(FirstName, LastName)
    {
        System.Diagnotistics.Contracts.Contract.Requires<ArgumentOutOfRangeException>(Grade >= 2 && Grade <= 6);

        this.FirstName = FirstName;
        this.LastName = LastName;
        this.Grade = Grade;
    }
}

Answer 3

There's another option, that might be a bit combersome but will ensure the given ranges, is not to use double at all, but create a custom class called Grade. Your Grade class will contain casts from and to double, and will enforce validation. This means that all Grade validation logic is in the Grade struct, and the Student class just receives a Grade object and doesn't have to worry about it.

public struct Grade
{
    public static readonly double MinValue = 2.0;
    public static readonly double MaxValue = 6.0;

    private double value;

    public static explicit operator double(Grade grade)
    {
        return grade.value + MinValue;
    }

    public static explicit operator Grade(double gradeValue)
    {
        if (gradeValue < MinValue || gradeValue > MaxValue)
            throw new ArgumentOutOfRangeException("gradeValue", "Grade must be between 2.0 and 6.0");

        return new Grade{ value = gradeValue - MinValue };
    }
}

And you would use it like this:

double userInput = GetUserInputForGrade();
Grade grade = (Grade)userInput; // perform explicit cast.
Student student = new Student(firstName, lastName, grade);

Edit: I've updated the code with @EricLippert's suggestions, to make the class expose its min/max values to a developer.

Edit 2: Updated again with @JeppeStigNielsen's suggestion. The value field now stores an offset from MinValue, so that a call to default(Grade) will return a valid value (equal to MinValue) regardless of whether 0 is inside the valid range.

Answer 4

class Student : Human 
{
    private double Grade;

    public Student(string FirstName, string LastName, double Grade)
        : base(FirstName, LastName)
    {
        if (Grade < 2 || Grade > 6)
            throw new ArgumentOutOfRangeException("Grade must be between 2 and 6");

        this.FirstName = FirstName;
        this.LastName = LastName;
        this.Grade = Grade;
    }
}

Answer 5

public Student(string FirstName, string LastName, double Grade)
    : base(FirstName, LastName)
    {
     if(Grade >= 2.0 || Grade <= 6.00)
      throw  new ArgumentException("your message");     
    }

Answer 6

If you want any chance of compile time cheking you have to use code contracts. They are essentially exceptions at runtime, so equivalent to argument validations with exceptions.

public Student(string firstName, string lastName, decimal grade)
{
    Contract.Requires(grade >= 2);
    Contract.Requires(grade <= 6);

    FirstName = firstName;
    LastName = lastName;
    Grade = grade;     
}

See this question

Design by contracts and constructors

Answer 7

class Student : Human 
{
    private double Grade;

    public Student(string FirstName, string LastName, double Grade)
        : base(FirstName, LastName)
    {
        this.FirstName = FirstName;
        this.LastName = LastName;
        this.Grade = Grade;
        if(Grade >= 2 and Grade <= 6){
            throw new Exception("Incorrect grade input");
    }
}

Or throw the relevent exception you want to e.g. ArgumentOutOfException etc...