Click here to Skip to main content
Click here to Skip to main content

NonNullable Class Wrapper

, 11 Apr 2008
Rate this:
Please Sign up or sign in to vote.
A wrapper to place the burden of checking a class reference for null on the calling method rather than the called method.

Background

A class reference may be null, but in many cases a method that accepts a class reference as a parameter requires that the reference be non-null.

(For the example snippets, we'll assume that returning 0 or -1 when a null is passed is not desirable.)

The naive thing to do in such cases is to simply allow .NET to throw a NullReferenceException the first time it is dereferenced:

public int CountOccurrences ( string String1 , string String2 )
{
    // Count the number of times String2 occurs in String1 and return that value
}

But this doesn't tell the calling method which value is null.

A smarter technique is to test the passed references, and throw a more informative exception:

public int CountOccurrences ( string String1 , string String2 )
{
    if ( String1 == null )
    {
        throw new System.ArgumentNullException 
            ( "String1" , "You must provide a string to search" ) ;
    }

    if ( String2 == null )
    {
        throw new System.ArgumentNullException 
            ( "String2" , "You must provide a string to find" ) ;
    }

    // Count the number of times String2 occurs in String1 and return that value
}

But this performs the check on each parameter every time the method is called.
In most cases, this is fine, but in some cases this seems unnecessary. Consider a usage of this method that is used to count all the occurrences of some string in the lines of a text file. In such a case, after reading each line, that line and the string to find are passed to this method whereupon the references are checked for null. That seems reasonable, but the second parameter will be checked on each call even though it doesn't change.

The test for null doesn't impose much of a performance hit, so this isn't really a performance issue. I'm more concerned here with readability and maintainability; the second snippet above is safer than the first but is perhaps harder to read and maintain.

What if we could write the method as simply as the first example, but with the safety of the second? Maybe something like this:

public int CountOccurrences ( NonNullable<string> String1, NonNullable<string> String2 )
{
    // Count the number of times String2 occurs in String1 and return that value
}

Implementation of My NonNullable<T> Structure

Unlike classes, structs can't be null, so I'll use a struct to wrap the class reference. Furthermore, wrapping a struct in a NonNullable<T> would be needless. So the beginning of our struct looks like:

public struct NonNullable<T> where T : class
{
    // Members
}

The struct needs only one field; it'll hold the class reference. The value won't change, so we can make it readonly, therefore we can also make it public and avoid writing a property for it:

public readonly T Value ;

Only one constructor is required; it'll simply perform the check for null and throw or store:

public NonNullable
(
    T Value
)
{
    if ( Value == null )
    {
        throw ( new System.ArgumentNullException ( "Value" , "That value is null" ) ) ;
    }

    this.Value = Value ;

    return ;
}

On second thoughts, many people don't like constructors that throw exceptions, so let's write one that won't throw. This requires that we have a fall-back position that will still yield a valid instance. Something like this ought to do:

public NonNullable
(
    T              Value
    ,
    NonNullable<T> IfNull
)
{
    if ( Value == null )
    {
        this.Value = IfNull.Value ;
    }
    else
    {
        this.Value = Value ;
    }

    return ;
}

Every type should override ToString():

public override string
ToString
(
)
{
    return ( this.Value.ToString() ) ;
}

By adding an implicit conversion to NonNullable<T>, the calling method need not know what's going on:

public static implicit operator NonNullable<T>
(
    T Value
)
{
    return ( new NonNullable<T> ( Value ) ) ;
}

However, there is a performance hit involved. Worse than that, the guidelines for implicit conversions state that they shouldn't throw exceptions, and this one may. And, as with the naive non-checking method, the caller won't know which parameter was null.

Add an implicit conversion from NonNullable<T> for convenience:

public static implicit operator T
(
    NonNullable<T> Value
)
{
    return ( Value.Value ) ;
}

Lastly, a pair of Coalesce methods to wrap the first non-null reference among those provided:

public static NonNullable<T>
Coalesce
(
    params T[] Values
)
{
    return ( Coalesce ( (System.Collections.Generic.IEnumerable<T>) Values ) ) ;
}

public static NonNullable<T>
Coalesce
(
    System.Collections.Generic.IEnumerable<T> Values
)
{
    if ( Values == null )
    {
        throw ( new System.ArgumentNullException 
            ( "Values", "No values were provided" ) ) ;
    }

    foreach ( T t in Values )
    {
        if ( t != null )
        {
            return ( new NonNullable<T> ( t ) ) ;
        }
    }

    throw ( new System.ArgumentException 
        ( "No non-null values were provided" , "Values" ) ) ;
}

Using the Code

Methods can be written as in the third snippet above:

public int CountOccurrences 
    ( NonNullable<string> String1 , NonNullable<string> String2 )
{
    // Count the number of times String2 occurs in String1 and return that value
}

And because I included the implicit conversion, the calling method doesn't need to know what the called method is doing. In fact, the called method could be rewritten to use NonNullable parameters without affecting the caller.

A better practice, when calling a method that takes NonNullable parameters is to wrap the value separately from making the call, especially when a value is used many times without changing.

...

int count = 0 ;
string line ;

// Check this value only once!
NonNullable<string> safetext = new NonNullable<string> ( text ) ; 
NonNullable<string> safeline

while ( ( line = file.Read() ) != null )
{
    safeline = new NonNullable<string> ( line )
    count += CountOccurrences ( safeline , safetext ) ;
}

...

(Note to self: Test with in, out, and ref parameters.)

Performance

As stated above, this technique is not intended to improve performance; it is meant to reduce code and therefore maintenance. Having said that; my testing has shown a modest improvement in performance at best and a considerable performance hit at worst. After ten million calls to a method-that-takes-a-string:

x 10000000 00:00:00.1204537  // with no check
x 10000000 00:00:00.1416811  // check the parameter on each call
x 10000000 00:00:00.3597213  // implicit conversion to NonNullable<string> on each call
x 10000000 00:00:00.2382019  // direct call to the NonNullable<string> constructor 
                             // on each call
x 10000000 00:00:00.1083238  // call the NonNullable<string> constructor once

History

  • 2008-04-11: First written

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

PIEBALDconsult
Software Developer (Senior)
United States United States
BSCS 1992 Wentworth Institute of Technology
 
Originally from the Boston (MA) area. Lived in SoCal for a while. Now in the Phoenix (AZ) area.
 
OpenVMS enthusiast, ISO 8601 evangelist, photographer, opinionated SOB
 
---------------
 
"If you need help knowing what to think, let me know and I'll tell you." -- Jeffrey Snover [MSFT]
 
"Typing is no substitute for thinking." -- R.W. Hamming
 
"I find it appalling that you can become a programmer with less training than it takes to become a plumber." -- Bjarne Stroustrup
 
ZagNut’s Law: Arrogance is inversely proportional to ability.
 
"Well blow me sideways with a plastic marionette. I've just learned something new - and if I could award you a 100 for that post I would. Way to go you keyboard lovegod you." -- Pete O'Hanlon
 
"linq'ish" sounds like "inept" in German -- Andreas Gieriet
 
"Things would be different if I ran the zoo." -- Dr. Seuss
 
"Wrong is evil, and it must be defeated." – Jeff Ello
 
"A good designer must rely on experience, on precise, logical thinking, and on pedantic exactness." -- Nigel Shaw
 
“It’s always easier to do it the hard way.” -- Blackhart

“If Unix wasn’t so bad that you can’t give it away, Bill Gates would never have succeeded in selling Windows.” -- Blackhart

"Omit needless local variables." -- Strunk... had he taught programming
 

 
"We learn more from our mistakes than we do from getting it right the first time."
 
My first rule of debugging: "If you get a different error message, you're making progress."
 
My golden rule of database management: "Do not unto others' databases as you would not have done unto yours."
 
My general rule of software development: "Design should be top-down, but implementation should be bottom-up."

Comments and Discussions

 
GeneralNice Article about irritatable one Pinmemberthatraja15-Jan-10 11:23 
GeneralRe: Nice Article about irritatable one PinmvpPIEBALDconsult16-Jan-10 4:42 
GeneralExcellent Pinmember-Dy14-May-08 1:09 
GeneralRe: Excellent PinmemberPIEBALDconsult14-May-08 13:01 
GeneralNice PinmvpPete O'Hanlon13-Apr-08 9:46 
GeneralRe: Nice PinmemberPIEBALDconsult13-Apr-08 9:57 
GeneralUnfortunately, NonNullable<t>.Value can be null</t> [modified] PinmemberDaniel Grunwald12-Apr-08 1:24 
GeneralRe: Unfortunately, NonNullable.Value can be null [modified] PinmemberPIEBALDconsult12-Apr-08 3:54 
GeneralRe: Unfortunately, NonNullable.Value can be null [modified] PinmemberPIEBALDconsult12-Apr-08 4:28 
AnswerRe: Unfortunately, NonNullable.Value can be null PinmemberPete Appleton14-Apr-08 23:02 
GeneralRe: Unfortunately, NonNullable.Value can be null PinmemberMember 43198654-May-08 13:59 
GeneralRe: Unfortunately, NonNullable.Value can be null PinmemberDean Goddard4-May-08 14:06 
GeneralRe: Unfortunately, NonNullable.Value can be null PinmemberPIEBALDconsult4-May-08 16:51 
GeneralInteresting! PinprotectorMarc Clifton11-Apr-08 11:41 
GeneralRe: Interesting! PinmemberPIEBALDconsult11-Apr-08 12:00 
GeneralRe: Interesting! PinprotectorMarc Clifton11-Apr-08 12:21 
GeneralRe: Interesting! PinmemberPIEBALDconsult11-Apr-08 13:27 
GeneralRe: Interesting! PinmemberPIEBALDconsult11-Apr-08 14:58 
GeneralRe: Interesting! Pinmemberaspdotnetdev10-Sep-10 6:53 
GeneralRe: Interesting! PinmvpPIEBALDconsult11-Sep-10 15:45 
GeneralI wrote exactly the opposite code last nite! Pinmember leppie 11-Apr-08 11:22 
GeneralRe: I wrote exactly the opposite code last nite! PinmemberPIEBALDconsult11-Apr-08 11:37 
GeneralRe: I wrote exactly the opposite code last nite! Pinmember leppie 11-Apr-08 11:55 
GeneralRe: I wrote exactly the opposite code last nite! PinmemberPIEBALDconsult11-Apr-08 12:01 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web03 | 2.8.140827.1 | Last Updated 11 Apr 2008
Article Copyright 2008 by PIEBALDconsult
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid