Using nullable types in C#

Question

I'm just interested in people's opinions. When using nullable types in C# what is the best practice way to test for null:

bool isNull = (i == null);

or

bool isNull = !i.HasValue;

Also when assigning to a non-null type is this:

long? i = 1;
long j = (long)i;

better than:

long? i = 1;
long j = i.Value;

Answer 1

I would always use the (i==null) form. It expresses what you are doing.

WRT the second question, I think either form is fine. However I'd always check it against null first and take appropriate action - perhaps wrapping that check and action up in a helper method (often it just sets a default value).

Answer 2

They're both the same, but I would use the former version on both, since it's more common in the language: comparison to null and casting to a type.

Answer 3

I usually tend to lean towards the first option in both scenarios, since it's more 'primitive' oriented opposed to object oriented (which was really what we were going for), but it really doesn't matter that much

Answer 4

I would use this:

long? i = 1;
...some code...
long j = i ?? 0;

That means, if i is null, than 0 will be assigned.

Answer 5

I haven't used Nullable Types in practice, but for the second, I'd actually suggest using j.GetValueOrDefault(). The documentation suggests that the latter would actually throw an InvalidOperationException in the event of a null value. Depending on the internal implementation of the explict cast operator for long?, the former might, too. I'd stick with GetValueOrDefault and treat the null/default case appropriately.

Answer 6

Use the forms that were specially implemented for you by the C# team. If anyone objects, tell them Anders said it was okay.

What I'm saying, flippantly, is that a lot of work went into integrating nullable types into c# to give you a good programming experience.

Note that in terms of performance, both forms compile down to the same IL, ie:

int? i = 1;
bool isINull = i == null;
int j = (int)i;

Ends up like this after the C# compiler has got to it:

int? i = 1;
bool isINull = !i.HasValue;
int j = i.Value;

Answer 7

I tend to use the first on both, because as it needs to be supported later in its life-cycle, these seem easier to understand what the intent of the original writer.

Answer 8

Opened up Reflector. HasValue is a lookup on a boolean flag which is set when the value is changed. So in terms of cycles a lookup is going to be faster then compare.

public Nullable(T value)
{
    this.value = value;
    this.hasValue = true;
}

private bool hasValue;

internal T value;

public bool HasValue
{
    get
    {
        return this.hasValue;
    }
}