Dismiss Notice
Join Physics Forums Today!
The friendliest, high quality science and math community on the planet! Everyone who loves science is here!

Dividing a function into separate validations and implementa

  1. Dec 6, 2015 #1
    So I'm reading a C# book in which the author (Jon Skeet) implements a Where function like

    Code (Text):

    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

    Code (Text):

    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.
     
  2. jcsd
  3. Dec 6, 2015 #2

    Filip Larsen

    User Avatar
    Gold Member

    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.
     
  4. Dec 6, 2015 #3

    mfb

    User Avatar
    2016 Award

    Staff: Mentor

    I wonder what happens if no suitable item is in the source...
    A call of the function without source or predicate is something that should never happen.
     
Know someone interested in this topic? Share this thread via Reddit, Google+, Twitter, or Facebook




Similar Discussions: Dividing a function into separate validations and implementa
  1. Valid variable names (Replies: 4)

Loading...