.NET 6 nullable properties warnings for EF Core models

Question

I'm using EF Core, and I have this model:

public class Article
{
    public int Id { get; set; }
    public User Author { get; set; } // <- CS8618
    public int AuthorId { get; set; }
}

As pointed out in the above code comment, I get an annoying nullable warning. I'm using the Fluent API to annotate my model, and obviously Author is not nullable as AuthorId is not nullable.

I feel that using User? Author instead to make the warning go away is incorrect, as the property is obviously not nullable, and it would be a lie, and also a hint to people using my model that it is nullable.

What is the proper way to deal with this situation? Suppress the warning?

Answer 1

Since C#11 (.NET 7.0) you can add a required modifier.

public class Article
{
    public int Id { get; set; }
    public required User Author { get; set; }
    public int AuthorId { get; set; }
}

And with the required modifier, you won't be able to use var article= new Article(); to create an object instance. So it's great protection for the not nullable property User.

Now to create an object instance you must do something like:

var article= new Article()
{
   User = new();
};

Originally answer was posted on: What is best way to create .NET6 class with many non-nullable properties?

More detailed info: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required

Answer 2

You'd find a lot of different answers on this question

But in this particular case, I would ask myself the question: who generates instances of this class?

1a

If you are 100% relying on EF Core to generate instances of this class for you by querying the database, and you are 100% sure that you ALWAYS use the proper Include(), I would safely set the Author field to null!, which means it assigns the default value null on construction and automatically suppresses the nullability error.

public class Article
{
    public int Id { get; set; }
    public User Author { get; set; } = null!;
    public int AuthorId { get; set; }
}

1b

You could also use the above solution with a private constructor to protect that no-one else but EF Core will generate instances of this class.

public class Article
{
    private Article()
    {
        Author = null!;
    }

    public int Id { get; set; }
    public User Author { get; set; }
    public int AuthorId { get; set; }
}

2

If you generate instances of this class in any other parts of your code, you would need a constructor to ensure that Author is never null after construction.

public class Article
{
    public Article()
    {
        Author = new User();
    }

    public int Id { get; set; }
    public User Author { get; set; }
    public int AuthorId { get; set; }
}

3

If you do not allow a default User object, it would make sense to expect a null value for Author but mark it Required to ensure that it will never be null when written to database.

public class Article
{
    public int Id { get; set; }

    [Required]
    public User? Author { get; set; }
    public int AuthorId { get; set; }
}

Answer 3

Common solution for domain entities is: use private default constructor for EF and public parameterized (keyless) one for explicit object creation. And there are two ways:

1. Mark props with reference type by "promises" (= null!;)
2. Disable warning on EF-constructor:

public class MyEntity {
    public int Id { get; [UsedImplicitly] private set; }
    public string Name { get; private set; }

    public MyEntity(string name) {
        Name = string.IsNullOrWhiteSpace(name)
            ? name
            : throw new ArgumentException(nameof(name));
    }

#pragma warning disable CS8618
    [UsedImplicitly]
    private MyEntity(){} // For EF only, allows to fill an object via setters
#pragma warning restore CS8618
}

Second approach is much better because checking still works with parameterized constructor. Private constructor makes minimal impact for type safety and doesn't require manual support.

Answer 4

Just put "#nullable disable" above the namespace.

Answer 5

If it is possible Author to be null make the User property nullable:

public User? Author { get; set; }

If not do this :

 public User Author { get; set; } = default!;