CODEWITHSUNDEEP
c#
Randy Minder
Randy Minder

Reputation: 48392

C# Nullable Types and the Value property

I'm a little unclear on when/if the Value property on nullable types must be used when getting the value contained in a nullable type. Consider the following example:

int? x = 10;

Console.WriteLine("The value of 'x' is " + x.Value);
Console.WriteLine("The value of 'x' is " + x);

Both of these return the same value (10).

However, if I initially set x to null, the first Console.WriteLine throws an exception and the second one does not.

So, my question is this. What is the point of using the Value property? It doesn't appear to be needed to get the actual value (even if it's null) and will throw an exception if the value is indeed null.

Upvotes: 26

Views: 20647

Answers (5)

manji
manji

Reputation: 47968

when x is null x.Value will throw a System.InvalidOperationException exception (no matter what is the type of x)

string + null = string : no exception

Upvotes: 2

reza.cse08
reza.cse08

Reputation: 6178

If you want to use .value for a nullable int. you can check the value like this

int? x = null;
int valXX = x.HasValue ? x.Value : 0;
Console.WriteLine("The value of 'x' is ->" + x + "<-");
Console.WriteLine("The value of 'valXX' is ->" + valXX + "<-");

Upvotes: 0

Jon Skeet
Jon Skeet

Reputation: 1499770

It is needed usually - just not in your particular case. The type of x is Nullable<int>, not int - and there's no implicit conversion from Nullable<T> to T.

Let's look at what's happening in your example though. Your final line is being converted into:

Console.WriteLine(string.Concat("The value of 'x' is ", x));

That's boxing x, which will result in either a boxed int or a null reference... both of which are handled by string.Concat.

When you're not converting to a string via string concatenation, e.g. if you wanted:

int nonNullable = x.Value;

then you do have to use the Value property - or an explicit cast, or possibly a null coalescing operator, or a call to GetValueOrDefault:

int nonNullable = (int) x;
int alternative = x ?? 20;
int andAnother = x.GetValueOrDefault(20);

Upvotes: 36

Tony Kh
Tony Kh

Reputation: 1572

You should access Value property if HasValue property returns true, otherwise you will get an exception. Your example works because Nullable has overloaded ToString() method and C# compiler supports shortcuts for this type.

Upvotes: 2

Andrey
Andrey

Reputation: 60055

x and x.Value have different types.

    static void Meth(int i)
    {
        int? x = 5;
        Meth(x);
        Meth(x.Value);
    }

Second line doesn't compile.

So reason of using x.Value is obvious - you need to call it when you need the actual value. And NullReferenceException is reasonable, because null doen't correspond to value of value type.

Upvotes: 10

Related Questions