Nullability of type parameters that are value types is erased when used as type parameters of another function

[ekolis]

I found this weird situation in the C# language where if I call a generic function and pass in a value type (e.g .int), then if I pass that value type parameter into another generic function but in nullable format (e.g .T?, which should resolve to int?), then the nullability of the type is erased, and the second generic function sees only the original non-nullable value type (int):

T GetDefault<T>()
{
	return default;
}

T? GetDefaultNullable<T>()
{
	return GetDefault<T?>();
}

Console.WriteLine(GetDefault<int?>()); // prints null as expected
Console.WriteLine(GetDefaultNullable<int>()); // prints 0 for some reason

Is this a bug in the type system? It's really frustrating me because I have to resort to reflection to get the correct nullable type that I want, and that's tricky and error prone.

[HaraGabi]

It is not a bug. int and int? are two different types. Specifically int? is really Nullable. T? means something different for value types and reference types.

Since you are specifying your first method with int? (aka Nullable, a reference type) its default value will be null.
Since you are specifying your second method with int (a value type) its default value will be... well the value types default value which is 0 for int.

As far as I know your best bet is to create 2 different GetDefaultNullable methods one for value and one for reference types.
T? GetDefaultNullable<T>() => default;
T? GetDefaultNullableValue<T>() where T : struct => default;

Edit: Nullable is a value type, as I has just learned. Still the answer is that default(int) is 0.

[lcsondes]

Nullable is a value type: https://learn.microsoft.com/en-us/dotnet/api/system.nullable-1

[HaraGabi]

Huh. TIL. Thank you for that. I always assumed it was a reference type for some reason.
With that said the answer is still, that default(Nullable) is null, while default(int) is 0.

[lcsondes]

There is a non-generic helper class named Nullable: https://learn.microsoft.com/en-us/dotnet/api/system.nullable

I would suggest adding where T : class to the other function, so that it can't accidentally get called with a value type.

[koszeggy]

Is this a bug in the type system?

No, it's evolution. Before C# 9.0 T? was not allowed without a constraint, which may cause some confusion today. See a more elaborated answer here.

[jnm2]

When T is not constrained to be a struct, and is not constrained to be a class, T? doesn't really mean "nullable." Rather, it means "defaultable." This still provides safety around actual nulls, but works around the constraints of the runtime and the metadata format which provide no way to dynamically wrap T with Nullable<T> in signatures when T is unconstrained, but happens to be a struct in a given call.

[jnm2]

One way to deal with this instead of reflection could be to declare the method twice with constraints to class and to struct, but that only works if T appears somewhere inside the parameter types.

[ekolis]

I didn't think that would work, though, since the compiler doesn't know if it's a class or a struct I'm passing in until runtime. C# doesn't have dynamic dispatch at that level, does it?

[jnm2]

Unfortunately, what I'm suggesting is to virally split all generic callers into pairs, one constrained to struct and the other to class. That is how you avoid reflection, and it's not always possible.

[ekolis]

Right, but even if I split them, how can I convince the compiler that I'm even allowed to call the split methods with any particular type that may or may not be a value type, unless I already know what that type is? Hence the reflection to call the appropriate method without the restrictions of the compiler.

[theunrepentantgeek]

the compiler doesn't know if it's a class or a struct I'm passing in until runtime. C# doesn't have dynamic dispatch at that level, does it?

Irrelevant to the current discussion, and not necessary to solve your current issue ... but, yes, C# can do exactly this. The keyword to research is dynamic.