Explicit cast should suppress warning for nullable types

[clairernovotny]

This is with the version in Preview 2.

Consider the following

void Foo(string bar)
{
}

void Frob(string? bbb)
{
    Foo((string)bbb); // Still generates warnings: uncessesary cast, CS8600, CS8604
}

There are many times when a nullable type may need to go into a place that's marked non-nullable. I would expect an explicit cast to work without warnings. It currently does not.

Here's my reasoning: an explicit cast is the developer saying "do this and throw if it breaks". It's also cleaner and inline with the language expressing intent. The alternative, of using pragma's around that line to suppress, is far more invasive to the code and makes it harder to read.

Here's the pragmas:

void Frob(string? bbb)
{
#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
#pragma warning disable CS8604 // Possible null reference argument.
    Foo(bbb); 
#pragma warning restore CS8604 // Possible null reference argument.
#pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type.
}

I think that's much worse.

[BillWagner]

Why not use this construct to indicate "do this and throw if it breaks"?

void Foo(string bar)
{
}

void Frob(string? bbb)
{
    Foo(bbb ?? throw new ArgumentNullException()); 
}

[clairernovotny]

It's still more code and seems to be more complex to read. That pattern also changes the logic, putting the checking on me. A cast would merely suppress the warning and let the existing logic/checking handle things whatever it might be. Null may actually be okay.

[DynConcepts]

I despise "case to clear warning" types with the C# style of casts. They are virtually impossible to reliably find in a code base [this is not a problem with C++ type cases (e.g. static_cast(...) ]

[cston]

The post-fix ! operator will suppress nullability warnings and the compiler will treat the expression as non-null.

    Foo(bbb!); // no warnings

[jaredpar]

Moving to csharplang as this is a language design question. The language team has already made a decision here and the compiler team is just following through on the implementation.

[clairernovotny]

While I don't care for the ! post-fix, it could just be new.... I think it'd help a lot of a Roslyn quick-fix offered to do that in addition to the pragmas.

This seems harder to read :/

[HaloFour]

@onovotny

Did you try putting the post-fix operator after the method call? It looks like the compiler is warning on assigning the object? result from GetValueFromLocalSettings<T>(name) to the variable object value, which sounds right to me.

[clairernovotny]

@HaloFour there are two places where the post-fix operator is required and adding them does make the warning go away.

[clairernovotny]

I've filed an issue to track a quick-fix for the ! post-fix operator: dotnet/roslyn#33360