What is the correct exception to throw for unhandled enum values?

Question

This is another case of my other question about unhandled cases with enums which I was recommended to ask as a separate question.

Say we have SomeEnum and have a switch statement handling it like:

enum SomeEnum
{
  One,
  Two
}

void someFunc()
{
  SomeEnum value = someOtherFunc();
  switch(value)
  {
     case One:
       ... break;
     case Two:
       ... break;
     default:
         throw new ??????Exception("Unhandled value: " + value.ToString());    
  }
}

As you see we handle all possible enum values but still keep a default throwing an exception in case a new member gets added and we want to make sure we are aware of the missing handling.

My question is: what's the right exception in such circumstances where you want to notify that the given code path is not handled/implemented or should have never been visited? We used to use NotImplementedException but it doesn't seem to be the right fit. Our next candidate is InvalidOperationException but the term doesn't sound right. What's the right one and why?

Answer 1

Personally, I add a custom exception to my project:

public class UnexpectedEnumValueException<T> : Exception
{
    public UnexpectedEnumValueException( T value )
        : base( "Value " + value + " of enum " + typeof( T ).Name + " is not supported" )
    {
    }
}

Then I can use it as needed:

enum SomeEnum
{
  One,
  Two
}

void someFunc()
{
  SomeEnum value = someOtherFunc();
  switch(value)
  {
   case SomeEnum.One:
    ... break;
   case SomeEnum.Two:
    ... break;
   default:
      throw new UnexpectedEnumValueException<SomeEnum>(value);    
  }
}

That way, I can do a search for "UnexpectedEnumValueException<SomeEnum>" when I, for example, a add new value to SomeEnum and I want to find all the places that could be impacted by the change. The error message is much more clear than a generic exception.

Answer 2

As it is an internal operation that fails (produces something invalid), InvalidOperationException is the way to go.

The docs simply say:

The exception that is thrown when a method call is invalid for the object's current state.

which is roughly fitting, because the current state of the object lead to an invalid return value of someOtherFunc, hence the call of someFunc should have been avoided in the first place.

Answer 3

Try using InvalidEnumArgumentException Class

void someFunc()
{
  SomeEnum value = someOtherFunc();
  switch(value)
  {
     case One:
       ... break;
     case Two:
       ... break;
     default:
          throw new InvalidEnumArgumentException(); 
  }
}

Answer 4

I think it depends on the semantics represented by the enum.

InvalidOperationException is appropriate if it represents an object state.

NotSupportedException is appropriate if it represents an application feature that isn't supported.

NotImplementedException is appropriate for an application feature that is not currently implemented but might be in a future version.

...

Answer 5

The ReSharper proposition for a switch case:

switch(parameter)
{
   default:
      throw new ArgumentOutOfRangeException("parameter");
}

But it might not fit your needs, in which case you can define a custom exception type regarding what is performed in this function: SomeEnumOutOfRangeException...

Answer 6

If a new value gets added and you've forgotten to handle it somewhere, it's a programming error, or a Boneheaded Exception as Eric Lippert calls them. I create my own BoneheadedException class which I throw whenever I detect a programming error for which no FCL exception type is more appropriate.

Answer 7

What I try to do in this situation is use a dictionary instead of a switch statement. (Generally, mappings like this are much better defined by a dictionary; I almost consider switch statements to be automatically code smells, because there are always or almost always better ways of organizing such a mapping.)

If you use a dictionary, then if you try to index your dictionary with a value that hasn't been accounted for, you'll get a KeyNotFoundException, and there's no longer a reason to ask "what do I do in the default case?".

Answer 8

This situation is really a contract failure and isn't necessarily specific to enums. If you can't use code contracts, you can create your own exception type and throw that.

case One:
   ... break;
 case Two:
   ... break;
 default:
    throw new ContractViolationException("Invalid enum");

Answer 9

These days I write two custom exceptions: UnexpectedValueException and UnexpectedTypeException. These seem to me like very valuable exceptions to have, since as soon as you've identified an occurrence of an unexpected (meaning assumed not to exist) value or type, you should throw with as meaningful a message as possible.

class UnexpectedValueException : Exception {
   public UnexpectedValueException(object pValue)
   : base($"The value '{pValue}' of type '{pValue?.GetType().ToString() ?? "<null>"}' was not expected to exist.") {
   }
}

enum SomeEnum {
   One,
   Two,
   Three
}

void someFunc() {
   SomeEnum value = someOtherFunc();

   switch (value) {
      case One: ... break;
      case Two: ... break;
      default: throw new UnexpectedValueException(value);    
   }
}

Answer 10

What I have settled to use is ArgumentOutOfRangeException with a custom error message inspired by the default message of InvalidEnumArgumentException (which I prefer not to use since it's inside System.ComponentModel):

The value of argument '{nameof(theArgument)}' ({theArgument}) is invalid for enum type '{nameof(TheEnumType)}'.

Here is what it looks like:

return level switch
{
    LogEventLevel.Verbose => "VERBOSE",
    LogEventLevel.Debug => "DEBUG",
    LogEventLevel.Information => "INFO",
    LogEventLevel.Warning => "WARN",
    LogEventLevel.Error => "ERROR",
    LogEventLevel.Fatal => "FATAL",
    _ => throw new ArgumentOutOfRangeException(nameof(level), level,
        $"The value of argument '{nameof(level)}' ({level}) is invalid for enum type '{nameof(LogEventLevel)}'.")
};

Answer 11

I would say NotImplementedException because you are throwing exception for an unimplemented enum value.