csharplang | official repo for the design of the C # programming language | Natural Language Processing library

You have a model with an optional value. Within a user-defined method you validate that this value is defined. The compiler can't determine this behaviour and thous the warning.

To help the compiler you could use the null-forgiving operator like this:

An init-only property doesn't require that properties are set at creation time with the property initializer syntax. It allows them to be set that way instead of requiring that all read-only properties are set by constructors.

So with your code,

Try opening the *.csproj file and adding to the tag. I added it to both DEBUG and RELEASE tags.

Not an answer really. It's too early for the feature :)
As @Yair mentioned: That's still not applicable to C# 9.

I've found the url to the docs: https://github.com/dotnet/csharplang/issues/2691
According to it: Was planned for 10.0 Candidate in Language Version Planning, but unfortunately was removed from it on 6 February 2021 (probably for a later version)

For now I am going to mark the question as resolved, but will come with a proper answer later, when we'll have fun with PrimaryContructors - that's how we will call them.
Thanks for tolerance

It is part of the C# pattern matching language feature, although not named explicitly as such.

The documentation about recursive pattern matching mentions it in the property pattern section, showing the ways to check for not null giving an example for a string.

Note that a null-checking pattern falls out of a trivial property pattern. To check if the string s is non-null, you can write any of the following forms

But what about cloning?

There are a lot of design decisions that just won't have satisfying answers. However, this one at least has a paper-trail you can follow in the design notes (in one or more mentions) starting at the following link.

_{Note : This was just an arbitrary decision, the reason they chose exclusive is because they chose exclusive. It could easily not have been the case due to the pros and cons}

C# Language Design Notes for Jan 22, 2018

...

Conclusion

Let us go with .. means exclusive. Since we've chosen to focus on the indexing/slicing scenario, this seems the right thing to do:

• It allows a.Length as an endpoint without adding/subtracting 1.
• It lets the end of one range be the beginning of the next without overlap
• It avoids ugly empty ranges of the form x..x-1

And as @vc74 mentions in the comments and also stated in the document supplied, other languages like python follow this convention, however others don't

Explanation of the problem

The problem in your first code sample occurs because compiler differently handles nullable value types and nullable reference types:

• Nullable value type T? is represented by type Nullable.
• Nullable reference type T? is the same type T but with a compiler-generated attribute annotating it.

Compiler cannot generate code to cover this both cases at the same time, therefore a compilation error occurs. And this error forces us to specify class or struct constraint. This behavior is also stated in the C# specification:

For a type parameter T, T? is only allowed if T is known to be a value type or known to be a reference type.

A good explanation of this problem can be found in this article: Try out Nullable Reference Types. Scroll to the paragraph "The issue with T?".

A workaround to fix the problem

The next workaround can be used if you don't want to create two methods with different names and suppress warnings:

You should explicitly declare a type of handler, instead of var