Best way to check function parameters: Check for null or try/catch

Question

when implementing/using methods that return or work with instances of objects, what is the most elegant approach to check the function parameters ?

Method to call:

someType GetSomething(object x)
{
    if (x == null) {
        return;
    }

    //
    // Code...
    //
}

or better:

someType GetSomething(object x)
{
    if (x == null) {
        throw new ArgumentNullException("x");
    }

    //
    // Code...
    //
}

Calling Method:

void SomeOtherMethod()
{
    someType myType = GetSomething(someObject);

    if (someType == null) {
        return;
    }

}

or better:

void SomeOtherMethod()
{
    try {
        someType myType = GetSomething(someObject);
    } catch (ArgumentNullException) {
    }
}

When browsing through similar questions, the reason not to use try/catch is performance. But IMHO the try-catch just looks better :).

So, which way is more "elegant"?

Answer 1

If passing in a null is not valid, throw an exception (i.e. - this is an exceptional situation that should never happen).

If a null parameter is valid, return a corresponding object.

In general, accepting null parameters is bad practice - it goes against the principle of least surprise and requires the caller to know it is valid.

Answer 2

As far as elegance is concerned, it's hard to top Code Contracts.

Contract.Requires(x != null);

Answer 3

You should only use exceptions for exceptional cases. If you expect the argument might be (legitimately) null, you should check it -- do not use exceptions for that. IMO you should check for null at the calling site (before the invocation) if it doesn't make sense to pass null to your method.