Proposal: Unrestricted Generic Type Support for Null-Coalescing

[sgjsakura]

As metioned in dotnet/roslyn#17754, currently comparison between a unrestricted generic type value and null is supported by the language specification, and the following code is already acceptable:

public void Test<T>(T value)
{
   var x = (value != null) ? value : default(T);
}

However, the newer null-coalescing cannot pass the compilation as the following:

public void Test<T>(T value)
{
   var x = value ?? default(T);
}

Does it possible to add support for this scene?

Thank you~

[Thaina]

There is an issue #36 about nullable reference type

Which I wish it could enable this code instead

public void Test<T>(T? value)
{
   var x = value ?? default(T);
}

[DavidArno]

@sgjsakura,

I'd personally prefer that var x = (value != null) ? value : default(T); didn't work either. But it does and stopping it would be a truly breaking change, so it makes sense to have ?? work the same way for consistency. So a +1 from me.

@Thaina,
Whilst having Nullable<T> support classes would be a handy feature, that seems orthogonal to this feature request.

[Thaina]

@DavidArno My point is I think we should keep the rule that struct should not be able to use ?? operator. It should always be explicit nullable
So even in generic we should keep this rule.But instead we should allow that every type should be able to have explicitly nullable state
Alternatively we should have generic constraint nullable

void Test<T>(T obj) where T : nullable
{
	var x = obj ?? default(T);
}

object obj = null;
Test(obj);

int? n = null;
Test(n);

[jnm2]

It does no harm to use ?? if T turns out to be struct. The jitter can elide the check for value types. It gives you the ability to do something you couldn't do before: evaluate the left expression only once.

[DavidArno]

@Thaina,

I disagree with you. Firstly,

But instead we should allow that every type should be able to have explicitly nullable state

would just spread the "world of null pain" to structs. Nullable<T> should rarely be used and then only used with care. Making it default behaviour for all structs would be a very bad thing in my view.

Secondly,

Alternatively we should have generic constraint nullable

means having to introduce a new keyword, which isn't a lightweight thing to do. Just allowing ?? to be used with structs seems a much simpler solution. It has the added bonus of making ?: and ?? consistent in their treatment of structs and null comparisons.

[CyrusNajmabadi]

I agree with this proposal. It seems very strange that one can write:

void Foo<T>(T value) {
     if (value == null) throw ...
}

But one can't write: value ?? throw ....

[MrJul]

Related inconsistency with pattern matching (in C# 7.1):
if (value is null) or (switch (value) { case null: ... }) should also compile fine.