When coding resharper recommends that if you're to discard or ignore the return of a method, that you use this syntax:
_ = TheMethodICouldCareLessAboutTheReturnValue();
I know you could just call it without assignment to _ just the same, so why does the _ as an assignment matter?
It matters for two reasons. One is conventional, the other technical.
The conventional reason is that _ conveys active disinterest in the returned value. Sure, you could write var dontcare instead, but that's just a different arbitrary value.
But as you pointed out, you could also omit the assignment, so it's not just about choosing the shortest name possible. This brings us to the technical reason.
There are cases where you have to declare a parameter and you cannot simply omit it. This applies to out parameters in method calls, and named tuples when you don't care about all of the tuple's members.
// Out params
if (DateTime.TryParse(dateString, out _))
Console.WriteLine("dateString can be parsed as a DateTime");
// Tuples
var (minimum, _) = FindMinMax(myData);
Console.WriteLine($"The minimum value is {minimum}");
There may be other use cases, these are the two I can think of because I encountered them before.
Is this necessary? Well, it's an easy way to suppress warnings about unused variables. Not all developers care about warnings, but those who do would be pestered by these useless warnings for cases where they are knowingly not using a variable that the compiler forced them to declare anyway.
_ being magic)
Commented
Oct 28, 2021 at 15:07
_ is "an easy way to suppress warnings about unused variables" - strictly speaking, to suppress a warning you use #pragma warning disable 01234 - whereas using a discard _ isn't "suppressing" a warning, it's about positively expressing your intent to ignore an unimportant or inconsequential result. The term "suppress" has connotations of basically sweeping issues under a rug (and invites future investigation during your next refactoring), whereas using discard is the opposite and implies finality and confidence.
By using the discard _, you are making it explicit that you, as the developer, understand that the method is returning a value but that you do not care about the value. This gives some insight into the code for reviews or future developers.
If you don't explicitly capture the return value, it is ambiguous as to your intention. Did you not realize that the method returns values? If you didn't realize that the method returned a value, does that also mean that you are missing a check against that return value against expectations? Or was it intentional and the return value doesn't mean anything in your context? These would be questions going through the mind of other developers that can easily be avoided with a very small change.
_ is slightly more than a standard variable name in that you can use it multiple times without error; var (_, _, foo) = bar; is valid while var (baz, baz, foo) = bar; is not.
Commented
Oct 28, 2021 at 15:06
var (discard1, discard2, foo), but there's no good reason to do that in a language like C# that lets you reuse the special _ name. Let me think on this wording a little bit.
_ is treated as a normal identifier and must be unique in a given lexical scope. Also, while you can have multiple separate _ discards inside a method, you cannot (unfortunately) have more than 1 discarded method parameter (which can happen when you're implementing an interface or using awkward out params).
Other answers have focussed on why the language includes the _ token, but I'd like to focus on why ReSharper is recommending it.
I think you are putting the emphasis on the wrong part of the message: ReSharper isn't asking you to add the _, it's asking you to check whether the return value is important.
As the answer by Thomas Owens puts it:
If you didn't realize that the method returned a value, does that also mean that you are missing a check against that return value against expectations?
The tool is saying "Hey! This function returns a value! Maybe it's important!" If that return value is an error code, failing to handle it could lead to a serious bug - and one which you won't notice until the error condition comes up.
The suggestion to discard it with _ is a side-effect of that check: it's a way of answering the tool with a "Thanks for pointing it out, I've had a look, and in this case it's not important." It's making use of the language syntax so that you don't have to write an ugly "ignore check" comment next to the line.
I think it's simply a natural bias in C# editors towards suggesting newer features. I think that as discard (the underscore) was added in C#7.0, editor maintainers looked for possible new suggestions, saw _=exprWithIgnorableReturn(); as a possible use, and added that hint. I don't think there was any deeper thought process than that.
My reasoning is, as has been noted, we've long been able to use var dontCare=exprWithIgnorableReturn(), but choose not to. C# editor extensions could have had "uncaught possibly unneeded return value, consider using a dummy?", but again, choose not to. The purpose of an ignoreable return value is that it can be ignored, as in completely ignored. Adding code to say "I realize this has a return value but choose to ignore it" is almost always clutter.
Something else also to consider is that you also make it clear to the compiler that you do not care about this value.
TheMethodICouldCareLessAboutTheReturnValue(out _)or (x, _, _) = TheMethodICouldCareLessAboutTheReturnValueTheMethodICouldntCareLessAboutTheReturnValue* ;)asdasd,aaa,aaaa, and so on.TheMethodICouldCareLessAboutTheReturnValueimplies some epsilon of caring, so the name is not entirely wrong. MaybeTheMethodICouldBarelyCareLessAboutTheReturnValue?