Dividing a function into separate validations and implementa

[SlurrerOfSpeech]

So I'm reading a C# book in which the author (Jon Skeet) implements a Where function like

public static IEnumerable<T> Where<T> ( this IEnumerable<T> source, Func<T,bool> predicate ) 
{
    if ( source == null || predicate == null ) 
    {
       throw new ArgumentNullException();
    }
    return WhereImpl(source, predicate);
}

public static IEnumerable<T> WhereImpl<T> (IEnumerable<T> source, Func<T,bool> predicate ) 
{
    foreach ( T item in source ) 
    {
        if ( predicate(item) )
       {
           yield return item;
       }
    }
}

Now, I fully understand how this works, and that it's equiavlent to

public static IEnumerable<T> Where<T> ( this IEnumerable<T> source, Func<T,bool> predicate ) 
{
    if ( source == null || predicate == null ) 
    {
       throw new ArgumentNullException();
    }
    foreach ( T item in source ) 
    {
        if ( predicate(item) )
       {
           yield return item;
       }
    }
}

which brings up the question of why would one separate these into 2 functions given that there would be memory/time overhead and of course more code. I always validate parameters and if I start writing like this example then I'll be writing twice as much code. Is there some school of thought which holds that validation and implementation should be separate functions?

Additionally, in another thread I made, someone said that `Exception`s should only be thrown if there has been an "extenuating circumstance" or something like that. In this case, an `Exception` is thrown because of an argument, which doesn't quite classify as an emergency.

 

[Filip Larsen]

The reason to check early for null parameters is that the method returns a Linq expression that may be evaluated in a completely different context far away, making the resulting NullReferenceException at that point hard to relate to the original call.

Jon Skeet usually have very good reasons for doing what he is doing, so I would venture a guess that he separates into two methods because he reuse the WhereImpl in other situations where he knows the parameters are well defined.

 

[mfb]

I wonder what happens if no suitable item is in the source...

Additionally, in another thread I made, someone said that `Exception`s should only be thrown if there has been an "extenuating circumstance" or something like that. In this case, an `Exception` is thrown because of an argument, which doesn't quite classify as an emergency.

A call of the function without source or predicate is something that should never happen.