This is effectively a duplicate of the answer that @stuartd linked, so I’m not going to go into super deep details here. But the root of the matter is that this is neither a language bug nor a compiler bug, but it’s intended behavior exactly as implemented. We track the null state of a variable. … Read more
For anyone ending up here. You can put #nullable enable on top of the file for a file-by-file approach as suggested by @Marc in the comments. You can also use combinations of #nullable enable/disable to annotate just parts of the file class Program { static void Main(string[] args) { #nullable enable string? message = “Hello … Read more
Basically you’re asking for something that can’t be represented in IL. Nullable value types and nullable reference types are very different beasts, and while they look similar in source code, the IL is very different. The nullable version of a value type T is a different type (Nullable<T>) whereas the nullable version of a reference … Read more
I can make a reasonable guess as to what’s going on here, but it’s all a bit complicated 🙂 It involves the null state and null tracking described in the draft spec. Fundamentally, at the point where we want to return, the compiler will warn if the state of the expression is “maybe null” instead … Read more
In Visual Studio 16.2 (from preview 1) the property name is changed to Nullable, which is simpler and aligns with the command line argument. Add the following properties to your .csproj file. <PropertyGroup> <Nullable>enable</Nullable> <LangVersion>8.0</LangVersion> </PropertyGroup> If you’re targeting netcoreapp3.0 or later, you don’t need to specify a LangVersion to enable nullable reference types. For … Read more
What to do if you are using C# 9 In C# 9, you can use T? on an unconstrained type parameter to indicate that the type is always nullable when T is a reference type. In fact, the example in the original question “just works” after adding ? to the property and constructor parameter. See … Read more
I would like to extend an existing answer by adding some links C# specification proposal says: nullable implicitly typed local variables var infers an annotated type for reference types. For instance, in var s = “”; the var is inferred as string?. It means that var for reference types infers a nullable reference type. This … Read more
You were very close. Just write your method like this: [return: MaybeNull] public T Get<T>(string key) { var wrapper = cacheService.Get(key); return wrapper.HasValue ? Deserialize<T>(wrapper) : default!; } You have to use the default! to get rid of the warning. But you can tell the compiler with [return: MaybeNull] that it should check for null … Read more
In .NET 6, APIs were added to handle this, see this answer. Prior to this, you need to read the attributes yourself. This appears to work, at least on the types I’ve tested it with. public static bool IsNullable(PropertyInfo property) => IsNullableHelper(property.PropertyType, property.DeclaringType, property.CustomAttributes); public static bool IsNullable(FieldInfo field) => IsNullableHelper(field.FieldType, field.DeclaringType, field.CustomAttributes); public static … Read more
The key to understanding what null! means is understanding the ! operator. You may have used it before as the “not” operator. However, since C# 8.0 and its new “nullable-reference-types” feature, the operator got a second meaning. It can be used on a type to control Nullability, it is then called the “Null Forgiving Operator” … Read more