Nullable ToString()

I see everywhere constructions like:

int? myVar = null;
string test = myVar.HasValue ? myVar.Value.ToString() : string.Empty;

Why not use simply:

string test = myVar.ToString();

Isn't that exactly the same ? At least Reflector says that:

public override string ToString()
{
  if (!this.HasValue)
  {
    return "";
  }
  return this.value.ToString();
}

So, is that correct (the shorter version) or am I missing something?

You are quite correct. Also in this question, the former solution is suggested while nobody actually notices ToString() already gives the correct answer.

Maybe the argument for the more verbose solution is readability: When you call ToString() on something that is supposed to be null, you usually expect a NullReferenceException, although here it isn't thrown.

I think that many people have such checks because it is not a natural behavior of an object that can hold null value.

No, you're correct, the shorter version is the same as what other folks have done in that regard. The other construct I tend to use a lot instead of the ternary with nullables is the null coalescing operator,. which also protects you from nulls. For ToString() it's not necessary (as you pointed out) but for default int values (for example) it works nicely, e.g.:

int page = currentPage ?? 1;

that lets you do all the integer operations on page w/o first explicitly null checking and calling for the value in currentPage (where currentPage is an int? perhaps passed as a param)

I know, long after it was relevant, but ... I suspect it is because for nullable types like int? the .ToString() method does not allow you to use format strings. See https://stackoverflow.com/questions/1833054/how-can-i-format-a-nullable-datetime-with-tostring . Perhaps in the original code, there was a format string in .ToString(), or perhaps the coder forgot that .ToString() without the format string was still available on nullable types.

Maybe it is just to follow a pattern? Or they don't know the backend. You are right that the code is exactly the same. You can even do:

int? i = null;
i.ToString(); //No NullReferenceException

int? is syntax sugar which simplifies declaration of nullable variable. It is the same as Nullable<int>.

So if you take a look at the implementation of ToString() method for Nullable<T> (see below), you can notice, that it returns empty string in case if it has no value.

public struct Nullable<T> where T : struct
{
    public override string ToString()
    {
      if (!this.hasValue)
        return "";
      return this.value.ToString();
    }
}

What MSDN says: > Nullable.ToString Method > > Returns the text representation of the value of the current Nullable object > if the HasValue property is true, or an empty string ("") if the > HasValue property is false.

So the following code will print empty string to console instead of throwing ArgumentNullException exception.

static void Main(string[] args)
{
    int? a = null;
    Console.WriteLine(a.ToString()); // Prints empty string to console.
}