Which exception to throw when an invalid code path has been taken?

Question

I find myself writing some methods where there is a code path that should never happen. Here is a simplified example:

double Foo(double x) {
    int maxInput = 100000;
    double castMaxInput = (double)maxInput;
    if (x < 0 || x > castMaxInput || double.IsNaN(x)) {
        return double.NaN;
    }
    double r = 0;
    for (double boundary = 1; boundary<=castMaxInput; boundary++) {
        if (x <= boundary) {
            r += boundary * (x + 1 - boundary);
            return r;
        }
        else {
            r += boundary;
        }
    }

    // we should never get here.
    throw new SomeException();
}

The exception that would make the most sense here is something like

TheAuthorOfThisMethodScrewedUpException() 

Because that's what is going on if we reach the end of the for loop. Unfortunately, with the method structured as above, the compiler does not appear to be smart enough to figure out that the code after the for loop should never happen. So you can't just have nothing there, or the compiler will complain that "not all code paths return a value". Yes, I could put in return double.NaN after the loop in addition to before it. But that would disguise the source of the problem.

My question is – is there an exception that would be appropriate?

Answer 1

I use the InvalidOperationException class for that. It means that the application has reached a state it should not be in.

throw new InvalidOperationException("Invalid state.");

You can also Debug.Assert that something is true, or simply Debug.Fail when execution reaches a particular point.

Debug.Fail("This should never happen!");

But debugging asserts/fails don't work in release mode, only when the DEBUG conditional is defined. Depends on your requirements whether that's desirable.

As @AlexD correctly points out, there's also the Trace class with its corresponding Assert and Fail methods, that will work at run-time to help isolate and fix problems without disturbing a running system, when the TRACE conditional is defined (is set by default in the Project Properties Build tab).

---

By the way, to answer the question in the title: you can create your own exceptions if you want.

[Serializable]
public class TheAuthorOfThisMethodScrewedUpException : InvalidOperationException
{
    private const string DefaultMessage = "The author of this method screwed up!";

    public TheAuthorOfThisMethodScrewedUpException()
        : this(DefaultMessage, null)
    { }

    public TheAuthorOfThisMethodScrewedUpException(Exception inner)
        : base(DefaultMessage, inner)
    { }

    public TheAuthorOfThisMethodScrewedUpException(string message)
        : this(message, null)
    { }

    public TheAuthorOfThisMethodScrewedUpException(string message, Exception inner)
        : base(message, inner)
    { }

    protected TheAuthorOfThisMethodScrewedUpException(
      System.Runtime.Serialization.SerializationInfo info,
      System.Runtime.Serialization.StreamingContext context)
        : base(info, context)
    { }
}

And throw it at people.

throw new TheAuthorOfThisMethodScrewedUpException();