为什么可以将空条件运算符应用于硬编码字符串？

Question

I have a bool variable like this:

bool myBool = true;

If I write if (myBool == null) I get the following warning:

The result of the expression is always 'false' since a value of type 'bool' is never equal to 'null' of type 'bool?'.

That's clear to me because it doesn't make sense to check whether a non-nullable variable is null. Visual Studio notices that and marks as warning.

Now I have a string , which is nullable by default, as I know.

Why can I apply a null-conditional operator to a hardcoded string without Visual Studio noticing it? I'm thinking of something like this:

"This is a string"?.AnyStringMethod();

Shouldn't Visual Studio notice that this string isn't null at all?

Answer 1

Warnings are for code that looks right but is actually wrong .

Your code looks wrong but does the right thing anyways .

Therefore: no warning.

Answer 2

Visual Studio must go off the type that the operator is working with.

When you create a bool , there is no way that it could ever be null by the type, until you change that type to bool? .

However, with a hard coded string, even though it has text within the quotes, there's no guarantee that it will stay there. The "variable" that gets created (even as just a plain string) is still of type string , which is able to have a null assigned to it and not change the type.

What you are looking for would be for them to inspect the value of every variable that they are creating. If they were to do that, then why not also check for something like this?

var i = 0;

if (i > 2) // This will always be false!

Update

As InBetween mentioned in the comments, there is a bit of an oversight in here as well. Having a string such as "Some string" that is not assigned in a variable is functionally equivalent to const string s = "Some string"; . If you were to declare it like that, the code inspectors will detect if you run a comparison on that, such as the following:

const string s = "Some String";
if (s == null) // This will give a warning that this can't happen

I would attribute that difference in the way that the const is handled versus the way a plain static string is handled could be attributed to different development teams working on different parts at different times. Again, this is such an edge case that doesn't cause huge problems that it doesn't get warned that no one working on it most likely didn't think about it.

Answer 3

Because no one thought about it? Your code is so pointless that probably no one foresaw it would ever be used in production code. I'm pretty sure this scenario didn't even crop up once in the C# design comittees although I'd take that with a grain of salt until someone like Eric Lippert sheds more light on the issue.

C# sharp isn't born with all potential features and then someone decides to prune it. In order for the compiler to give a certain warning someone has to think about it, implement it, test it and document it.

In case of myBool == null , the warning is justified becuase its a plausible error that could potentially make it into production code and its clearly a bug in the program's logic. The second scenario is completely harmless even if it ends up making it into production, so the warning really doesn't make much sense.

Answer 4

Because bool is of a value type while string is a reference type

Value types cannot be null, but reference types are automaticly nulled through Default

The reason Visual Studio doesn´t notice, is because it is of no importancable really.. it is like asking if blue is more of a color than green

Answer 5

A string literal is slightly different than a string object. I believe the string literal is basically like a constant, it is immutable, and will not ever be null.

When you assign a string literal to a variable, you are creating a reference to the string in a memory location. That reference can be null. If you try to concatenate your string variable with another string and store back in your original string variable, the original string in memory is destroyed and a new string is created that is the concatenated string. This is because strings are always immutable.