Added: C# Language Design Notes for Aug 14, 2017

[MadsTorgersen]

C# Language Design Notes for Aug 14, 2017

We looked at the interaction between generics and nullable reference types

1. Unconstrained type parameters
2. Nullable constraints
3. Conversions between constructed types

Please discuss!

[svick]

If we embrace defaultable T?, it would technically be a correct type for the out parameter of TryGet methods […] There should probably be a special mechanism for this scenario.

That sounds a lot similar to #727. Is that how the "special mechanism" could look like?

[yaakov-h]

Let's embrace T? in the prototype and look out for confusion, usage, implementation issues, etc.

👍

[Joe4evr]

Something that occurs to me now that you're talking about generics: What are all the places that ? should go? Given this example code (pre-nullable annotations):

public class Foo<TBar>
    where TBar : Bar
{
    public TBar Bar { get; }
}

The Bar property can be null, so the obvious thing to do once the annotations are turned on is add the ? there: public TBar? Bar { get; }

Does this now produce a warning because of the class declaration? If yes, then how would I resolve that?

//Option 1:
public class Foo<TBar?>
//-----------
//Option 2:
    where TBar? : Bar
//-----------
//Option 3:
    where TBar : Bar?
//-----------
//Possibly some combination?

I think that it sounds like option 3 by itself is how it could go, which is also what I like the most. (For the record: I like option 1 the least, since that may pre-empt my following question.)

Secondly: If nullability is explicitly stated by a constraint like option 3, does it still need to be stated at use-sites? I'm hoping "No", since the type argument doesn't change the fact that the base class property type is annotated with ?.

//Should not require the `?`
var foo = new Foo<DerivedBar>();
var bar = foo.Bar; //type: 'DerivedBar?'

//Neither here
public class DerivedFoo : Foo<DerivedBar>
{
}

[orthoxerox]

Perhaps TryFoo methods should be recognized by the nullability flow analyzer? Either by shape alone or via a special attribute on the out parameter (NullWhenMethodReturns(false) or something like that).

[orthoxerox]

Regarding the class constraint.

Does this mean we will be able to use T? only as an argument/return type, but not as a generic parameter itself, unlike structs? That doesn't look too good, but is probably the best option. Is my understanding written bellow correct?

class Foo<T> where T : class means "I don't expect you to pass nulls where I expect instances of T and I promise I won't return a null where I return an instance of T. If I think nulls are OK or unavoidable in some specific case, I will write T? in the method header. Therefore, T cannot be a nullable reference type".

class Foo<T> where T : class? means "If you don't plan to pass me nulls, specify T as a non-explicitly-nullable reference type, and I also won't return you nulls except where I've indicated that by return type T?. If you plan to pass me nulls where I expect a T, specify T as an explicitly nullable reference type, but then I can't promise I will not return a null even where I say T is the return type."

This raises an important issue with IEnumerable<T> similar to TryGetValue(), by the way. If T is string and MoveNext() returned true, I would expect Current to return a string, not a string?.