When we put ? after reference type we allow the instance to be null. So we have string?[] – string array where we allow the items to be null (but array itself can’t be null) string[]? – string array which can be null itself (but it can’t have null items) string?[]? – both array and … Read more
In my case, I ran into this problem with Visual Studio 2022 when I changed the target framework from .NET Standard 2.1 to .NET Standard 2.0. I solved my problem by removing <Nullable>enable</Nullable> in the .csproj file and restarting Visual Studio. Original .csproj file: <PropertyGroup> <TargetFramework>netstandard2.1</TargetFramework> <Nullable>enable</Nullable> </PropertyGroup> New .csproj file: <PropertyGroup> <TargetFramework>netstandard2.0</TargetFramework> </PropertyGroup>
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
Ok, just found out that you can use notnull constraint: public static TValue Get<TKey, TValue>( this Dictionary<TKey, TValue> src, TKey key, TValue @default) where TKey : notnull => src.TryGetValue(key, out var value) ? value : @default;
You can do either of the following: EF Core suggests initializing to null! with null-forgiving operator public string ServiceUrl { get; set; } = null! ; //or public string ServiceUrl { get; set; } = default! ; Using backing field: private string _ServiceUrl; public string ServiceUrl { set => _ServiceUrl = value; get => _ServiceUrl … Read more
You have to update your extension method to the following public static IEnumerable<T> NotNull<T>(this IEnumerable<T?> enumerable) where T : class { return enumerable.Where(e => e != null).Select(e => e!); } The point here is that you are converting the IEnumerable of nullable references to not nullable ones, therefore you’ll have to use IEnumerable<T?>. where T … Read more
Given a function in a program using C# 8.0’s nullable reference types feature, should I still be performing null checks on the arguments? That depends on how certain you are of all the paths through your API. Consider this code: public void Foo(string x) { FooImpl(x); } private void FooImpl(string x) { … } Here … Read more
As an option, you can use the default literal in combination with the null forgiving operator public class Item { public string Id { get; set; } = default!; public string Name { get; set; } = default!; public string Description { get; set; } = default!; } Since your DTO is populated from DynamoDB, … Read more
There is no proper way to handle non-nullable navigational properties. Documentation suggests two ways and both are not type safe. Use a backing field and throw InvalidOperationException. It is unclear how it differs from doing nothing and have a NullReferenceException Suppress it with null forgiving operator Official documentation link: https://learn.microsoft.com/en-us/ef/core/miscellaneous/nullable-reference-types#non-nullable-properties-and-initialization
Whenever you want to tell the compiler “shut up, I know what I’m doing” in regards to nullable reference types, use the ! operator. You can fix your issue by declaring your properties like so: public DbSet<Probe> Probes { get; set; } = null!; public DbSet<ProbeUnitTest> ProbeUnitTests { get; set; } = null!;