Representing a property with a non-nullable getter & a nullable setter I have a class as follows, where I want the user of the class to know that setting the Slug property to null is supported, and its getter will still return a valid value:
public class Post
{
    public string Title { get; }
    public Post(string title)
    {
        Title = title;
    }

    private string? slug;
    public string Slug 
    { 
        get
        {
            if(slug is null)
            {
                slug = Title.Slugify();
            }
            return slug;
        }
        set =&gt; slug = value;
    }
}

There are two possible cases here:
CASE 1: No slug is set on/after initialization OR the slug is initialized with a non-null string.
var post = new Post(&quot;foo bar&quot;);
var slug = post.Slug;               // foo-bar

var post2 = new Post(&quot;foo bar 2&quot;) { Slug = &quot;foo-bar-2&quot; };
var slug2 = post.Slug;              // foo-bar-2

CASE 2: The slug set on is initialization with a nullable string.
string? maybeNull = viewModel.Slug; // may or may not be null
var post = new Post(&quot;foo bar&quot;) { Slug = maybeNull! };
var slug = post.Slug;               // returns an expected value

Is there a better way to do this, than using the null forgiving operator? The above code looks worse if I had to set it to null:
var post = new Post(&quot;foo bar&quot;) { Slug = null! };
var slug = post.Slug;               // returns an expected value

The reason I dont want to use the null forgiving operator is because it requires the user of the Post class to know that a null value can be safely passed into its Slug property -- something I wish to avoid.
If it's not possible to have different nullability for getters and setters (appears to me like it's not), what is the best way to communicate my intent (users can safely set Slug to null + users will always get a valid slug, irrespective of what was set).
For some more context:

the Post class is instantiated with a nullable value only while creating a Post. Every other time, it's going to be pulled from a database, and so will always be instantiated with a valid slug.
the Post class is not a ORM model.
I'm thinking you should probably change your Post class as follows:
public class Post
{
    public string Title { get; }
    public string Slug { get; set; }
    public Post(string title)
    {
        Title = title;
        Slug = title.Slugify();
    }
}

Now you have a slugified title by default. However, if a user of the Post class wants to provide an alternative slug, they can still do that:
var post = new Post(&quot;foo bar&quot;) { Slug = altSlug };

The explanation for the user should be that they can either provide a slug explicitly, or have one auto-created by omitting it from the initializer. The only thing you cannot do with this code is set Slug to null explicitly. But I think it would not be good design to allow that.
On a side note, you might even want to make the Slug property getter-only, creating an immutable class, and providing a second constructor that takes the alternative slug. This makes reasoning easier:
public class Post
{
    public string Title { get; }
    public string Slug { get; }
    public Post(string title) : Post(title, title.Slugify()) {}
    public Post(string title, string slug)
    {
        Title = title;
        Slug = slug;
    }
}