Non-Nullable becomes Nullable on return

Question

I think I've seen this question answered somewhere, but I can't find it and don't remember the answer.

Assuming Nullable-Reference-Types is enabled.

There is a method that returns a string. The caller of the method stores the resulting string into a variable. The variable will be Nullable, even if the method's return value is non-nullable.

static string MyMethod() 
{
   return "Hello World!";
}

public static void Main() 
{
   // result is of type string? here. Hence nullable.
   var result = MyMethod();
}

The same does not seem to happen with primitive types, but it does happen reference types, like object. Kind of defeats the purpose of NRT for me. I'm sure there's a reason for this and it's "by design".

Answer 1

This is indeed by design.

The meeting notes where this design was chosen are here: https://github.com/dotnet/csharplang/blob/main/meetings/2019/LDM-2019-12-18.md#var

To summarise: It was found that people were frequently having to explicitly type the variable rather than using var because after assignment from a non-null-returning method, the code went on to assign null to the variable.

To quote from the meeting notes:

At this point we've seen a large amount of code that requires people spell out the type instead of using var, because code may assign null later.

That is, code like the following was found to be quite frequent:

var someVariable = SomeMethodThatDoesntReturnNull();
...
someVariable = null; // or someVariable = someMethodThatCanReturnNull();

Note that (as pointed out by Jeroen Mostert) result2 in your question is NOT nullable because it's explicitly typed as non-nullable. I'm not sure why you think it is nullable, but it definitely isn't.

For example, look at this repro on DotNetFiddle and note the warning on line 11.