C# Throwing Exceptions in Immutable Classes

Question

I was reading here about creating immutable classes in C#. It was suggested I make my classes this way for real immutability:

private readonly int id;

public Person(int id) {

    this.id = id;
}

public int Id {
    get { return id; }
}

I understand that, but what if I wanted to do some error checking, how can I throw an exception? Given the following class, I can only think to do it this way:

private readonly int id;
private readonly string firstName;
private readonly string lastName;

public Person(int id,string firstName, string lastName)
{
    this.id=id = this.checkInt(id, "ID");
    this.firstName = this.checkString(firstName, "First Name");
    this.lastName = this.checkString(lastName,"Last Name");

}

private string checkString(string parameter,string name){

    if(String.IsNullOrWhiteSpace(parameter)){
        throw new ArgumentNullException("Must Include " + name);
    }

    return parameter;

}

private int checkInt(int parameter, string name)
{
    if(parameter < 0){

        throw new ArgumentOutOfRangeException("Must Include " + name);
    }
    return parameter;   
}

Is that the correct way of doing it? If not, how would I accomplish throwing exceptions in immutable classes?

Answer 1

I would inline these two private methods:

  private readonly int id;
  private readonly string firstName;
  private readonly string lastName;

  public Person(int id, string firstName, string lastName)
  {
     if(String.IsNullOrWhiteSpace(firstName))
        throw new ArgumentNullException("firstName");
     if(String.IsNullOrWhiteSpace(lastName))
        throw new ArgumentNullException("lastName");
     if(id < 0)
        throw new ArgumentOutOfRangeException("id");


     this.id=id;
     this.firstName = firstName ;
     this.lastName = lastName ;
  }

Answer 2

If you use a private setter, the property can be set through reflection, so it is not immutable. This may or may not be a problem for you in this example. Personally I prefer your method as it is definitely and immutable and other coders can infer the intent easily.

In any case, you because your data is immutable, your errors are also immutable, so will never change. The pattern that you have followed is correct.

You are correct in checking for errors in the constructor, because you don't want to create an immutable object with errors.

[I would have liked to have written this as a comment, instead of an answer, but I am^H^H was 1 point short on reputation. I'll leave it here now.]

Answer 3

C# 6 supports immutable getter-only auto properties, so if you are using Visual Studio 2015 you could further refactor like this:

  public int Id { get; }

  public Person(int id, string firstName, string lastName)
  {
     if (id < 0)
        throw new ArgumentOutOfRangeException("id");

     Id=id;
  }

I've restricted the example to the ID property only. The constructor validates the value and assigns it to the property if valid, and the property is fully immutable plus you have not had to explicitly declare a backing field. This is nicely documented with a refactoring demonstration on the Resharper website.

Answer 4

If it's necessary to mark field as readonly - there is no other option than to do error checking inside ctor. Readonly fields can only be modified in constructor or initialization block.

Simply do something like this :

public Person(int id) {
    if(id > 1200) throw new Exception(); // or put it in separate method
    this.Id = id;
}

You can even go further and use generic method like :

private void CheckValue<T>(T parameter, string name)
{
       if(T is int) if((parameter as int) < 0) throw new ArgumentOutOfRangeException(name));
       if(T is string) if(String.IsEmptyOrWhiteSpace(parameter as string)) throw new ArgumentNullException(name));
      //   ... if (T is) ... other types here
   }
}

in ctor :

public Person(int id, string name) {
    CheckValue(id, "id");
    CheckValue(name, "name");
    this.Id = id;
}