Question

When is it appropriate to use a ThrowHelper method instead of throwing directly?

void MyMethod() {
    ...
    //throw new ArgumentNullException("paramName");
    ThrowArgumentNullException("paramName");
    ...
}
void ThrowArgumentNullException(string paramName) {
    throw new ArgumentNullException(paramName);
}

I’ve read that calling a ThrowHelper method (a method with the only purpouse of throwing an exception) instead of throwing directly should yield smaller bytecode.

This, and the obvious encapsulation (another layer of indirection), may be good reasons to not throw directly, at least in some scenarios.

Anyway, IMO the drawbacks are not insubstantial too.

• A part of the (exceptional) control flow is hidden
• Exceptions end up having a more cryptic stacktrace
• the compiler (2.0) will not recognize that ThrowHelper calls are exit points from a method, hence some code-around is necessary.

My limited experience is that often the overall design gets worse.

int MyMethod(int i) {
    switch (i) {
        case 1:
            return 1;
        default:
            ThrowMyException();
    }
    return 0; // Unreachable (but needed) code
 }

This may partly be a matter of personal taste. Anyway what are your personal guidelines about this issue? Do you find it is a good idea to use ThrowHelpers for all those common tasks like method param validation (ThrowArgumentNullException(paramName) and such)?
Am I missing something obvious on this issue?

Btw I’m trying not to mix this issue with the validation issue, e.g. a method like:

ThrowIfNameIsNullOrEmpty(name);

Answer 1

My default approach is to throw directly from the exceptional code branch.

The DRY principle and the rule of 3 guides when I would wrap that in a method: if I find myself writing the same ‘throw’ code 3 or more times, I consider wrapping it in a helper method.

However, instead of a method that throws, it’s much better to write a Factory Method that creates the desired Exception and then throw it from the original place:

public void DoStuff(string stuff)
{
    // Do something

    throw this.CreateException("Boo hiss!");
}

private MyException CreateException(string message)
{
    return new MyException(message);
}

This preserves the stack trace.