Click here to Skip to main content
12,348,451 members (66,742 online)
Click here to Skip to main content
Add your own
alternative version

Tagged as

Stats

29.7K views
104 downloads
20 bookmarked
Posted

NonNullable Class Wrapper

, 11 Apr 2008 CPOL
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, acknowledged pedant and contrarian

---------------

"Using fewer technologies is better than using more." -- Rico Mariani

"Good code is its own best documentation. As you’re about to add a comment, ask yourself, ‘How can I improve the code so that this comment isn’t needed?’" -- Steve McConnell

"Every time you write a comment, you should grimace and feel the failure of your ability of expression." -- Unknown

"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

You may also be interested in...

Comments and Discussions

 
GeneralNice Article about irritatable one Pin
thatraja15-Jan-10 11:23
memberthatraja15-Jan-10 11:23 
GeneralRe: Nice Article about irritatable one Pin
PIEBALDconsult16-Jan-10 4:42
mvpPIEBALDconsult16-Jan-10 4:42 
GeneralExcellent Pin
-Dy14-May-08 1:09
member-Dy14-May-08 1:09 
GeneralRe: Excellent Pin
PIEBALDconsult14-May-08 13:01
memberPIEBALDconsult14-May-08 13:01 
GeneralNice Pin
Pete O'Hanlon13-Apr-08 9:46
mvpPete O'Hanlon13-Apr-08 9:46 
GeneralRe: Nice Pin
PIEBALDconsult13-Apr-08 9:57
memberPIEBALDconsult13-Apr-08 9:57 
GeneralUnfortunately, NonNullable<t>.Value can be null</t> [modified] Pin
Daniel Grunwald12-Apr-08 1:24
memberDaniel Grunwald12-Apr-08 1:24 
GeneralRe: Unfortunately, NonNullable.Value can be null [modified] Pin
PIEBALDconsult12-Apr-08 3:54
memberPIEBALDconsult12-Apr-08 3:54 
GeneralRe: Unfortunately, NonNullable.Value can be null [modified] Pin
PIEBALDconsult12-Apr-08 4:28
memberPIEBALDconsult12-Apr-08 4:28 
AnswerRe: Unfortunately, NonNullable.Value can be null Pin
Pete Appleton14-Apr-08 23:02
memberPete Appleton14-Apr-08 23:02 
GeneralRe: Unfortunately, NonNullable.Value can be null Pin
Member 43198654-May-08 13:59
memberMember 43198654-May-08 13:59 
GeneralRe: Unfortunately, NonNullable.Value can be null Pin
Dean Goddard4-May-08 14:06
memberDean Goddard4-May-08 14:06 
GeneralRe: Unfortunately, NonNullable.Value can be null Pin
PIEBALDconsult4-May-08 16:51
memberPIEBALDconsult4-May-08 16:51 
GeneralInteresting! Pin
Marc Clifton11-Apr-08 11:41
protectorMarc Clifton11-Apr-08 11:41 
GeneralRe: Interesting! Pin
PIEBALDconsult11-Apr-08 12:00
memberPIEBALDconsult11-Apr-08 12:00 
GeneralRe: Interesting! Pin
Marc Clifton11-Apr-08 12:21
protectorMarc Clifton11-Apr-08 12:21 
GeneralRe: Interesting! Pin
PIEBALDconsult11-Apr-08 13:27
memberPIEBALDconsult11-Apr-08 13:27 
GeneralRe: Interesting! Pin
PIEBALDconsult11-Apr-08 14:58
memberPIEBALDconsult11-Apr-08 14:58 
GeneralRe: Interesting! Pin
aspdotnetdev10-Sep-10 6:53
memberaspdotnetdev10-Sep-10 6:53 
GeneralRe: Interesting! Pin
PIEBALDconsult11-Sep-10 15:45
mvpPIEBALDconsult11-Sep-10 15:45 
GeneralI wrote exactly the opposite code last nite! Pin
leppie 11-Apr-08 11:22
member leppie 11-Apr-08 11:22 
GeneralRe: I wrote exactly the opposite code last nite! Pin
PIEBALDconsult11-Apr-08 11:37
memberPIEBALDconsult11-Apr-08 11:37 
GeneralRe: I wrote exactly the opposite code last nite! Pin
leppie 11-Apr-08 11:55
member leppie 11-Apr-08 11:55 
GeneralRe: I wrote exactly the opposite code last nite! Pin
PIEBALDconsult11-Apr-08 12:01
memberPIEBALDconsult11-Apr-08 12:01 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    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 | Terms of Use | Mobile
Web01 | 2.8.160621.1 | Last Updated 11 Apr 2008
Article Copyright 2008 by PIEBALDconsult
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid