c# conditional operator without else

[NiklasRaab]

Please provide support for conditional operator without an else. For example:
string returnValue = someBool ? "this is a return value"

At the moment you have to write:
string returnValue = someBool ? "this is a return value" : null
or
string returnValue = someBool ? "this is a return value" : default(string)

Thank you for the general statement blow:
T value = someBool ? <some T value> : default(T);

It would be small but nice 👍

[HaloFour]

What is the result for such an expression supposed to be? null? Unassigned?

[DavidArno]

Like @HaloFour, I'm confused as to what would happen when the expression is false.

It can't be unassigned, as the compiler wouldn't then let you use returnValue as it might not be assigned, making it a rather pointless feature. So maybe:

string returnValue = someBool ? "this is a return value";

would be the equivalent of:

string returnValue = someBool ? "this is a return value" : null;

This can be generalised to:

T value = someBool ? <some T value> : default(T);

But, in your example, you want it to be equivalent to string.Empty, which wouldn't work unless a special case were made for string. This would be a violation of the principle of least astonishment, as why should just one type have a different behaviour?

Sorry, but I don't think this is a good suggestion.

[NiklasRaab]

@HaloFour @DavidArno Thank you for answering. I have updated my issue. Sorry for being so complicated :(

I think its a great idea how @DavidArno has generalised this. He is understanding me better then myself :)

T value = someBool ? <some T value> : default(T);

[aloisdg]

I think the value should be default(T) or the old value.

For example, instead of writing:

var sample = "foo";
var statement = true;
if (statement)
{
    sample = "bar";
}

or even (With a useless else part of the ternary operator) :

var sample = "foo";
var statement = true;
sample = statement ? "bar" : sample;

I would love to be able to write:

var sample = "foo";
var statement = true;
sample = statement ? "bar";

It would be a really sweet sugar 👍

[NiklasRaab]

@aloisdg I understand you, but one question. How would you handle something like this (calling the operator in a parameter):
Math.Round(someBoolean ? 10.1)
What do you return if someBoolean is false?

Should be default(T) returned?

[aloisdg]

@NiklasRaab Indeed. I think default(T) should be return.

[ig-sinicyn]

@aloisdg so,

var sample = "foo";
var statement = false;
sample = statement ? "bar";

should left sample = "Foo", but

var sample = "foo";
var statement = false;
sample = String.Intern(statement ? "bar");

will make sample to be empty? Kinda scary.

[aloisdg]

@ig-sinicyn Why is it scary? String.Intern will get null and it will throw.

Edit:

String.Intern will throw if you give it null. It is the behavior of String.Intern.

[ig-sinicyn]

@aloisdg

Why is it scary? ... it will throw.

Oh, thanks. Now it's much better.

[aloisdg]

@ig-sinicyn sarcasm, isnt it? I am not sure. In your case why wouldn't you use a classic ternary operatyor: String.Intern(statement ? "bar" : sample);?

[HaloFour]

@aloisdg

Expressions and assignments are two different things. The expression statement ? "bar" would have to be parsed and evaluated on its own, independently of whatever you do with it. What would SomeMethod(statement ? "bar") do?

[aloisdg]

@HaloFour return default(T).

As said before, in your code, just use a ternary operator. To use @ig-sinicyn example:

using System;
					
var sample = "foo";
var statement = false;
sample = string.Intern(statement ? "bar" : sample);

Console.WriteLine(string.IsNullOrEmpty(sample) ? "empty" : sample)

or why not

using System;
					
var sample = "foo";
var statement = false;
sample = statement ? "bar";

Console.WriteLine(string.IsNullOrEmpty(sample) ? "empty" : string.Intern(sample));

[ig-sinicyn]

@aloisdg

why wouldn't you use a classic ternary operator

Because I can. As far as I can see it is same motivation that inspired this proposal as well as many others, #196, #183, #170 to name a few. I do not think that ability to write

if not !(?!x?.Y?z?a??a2???a3??!a4!) ...

is a good addition to c#. We have an APL for this : )

[aloisdg]

By the way, I dont say that it is feasible. It may not. I dont know. I see OP idea and I see myself using an operator like this one.

[aloisdg]

@ig-sinicyn It is called Syntactic sugar. For example the + operator or the lambda are sugars. I dont think we should put sugar everywhere. It will result like APL or J or Pyth or whatever language great for golfing. We are not here for that. A bit of sugar is helpful. It reduces cognitive load. If you put to much, we will have to know them all and it will be APL. We have to find a balance.

Is this feature helpful? Why someone would want to use it? What are we looking to resolve? I see OP problem. I see an idea of a solution. (Maybe not a working one 😄 )

[ig-sinicyn]

@aloisdg

I see you point but I'd prefer to have c# team being focused on a real issues instead of reinventing one more way to write the if() statement :)

Ok, there is half a dozen ways to declare a property and more is coming. Should all other parts of a language to be doomed in a same manner?

[aloisdg]

@ig-sinicyn Sure. I agree this one is not a priority, but I don't think it is a bad one. The language is alive and it is nice. Nobody forces anyone to use var... And if you really hate sugar, Lisp is a fun language. ;)

[DavidArno]

@aloisdg,

You have taken a proposal of questionable worth and turned it into one that fundamentally changes the way the compiler would have to work in order to achieve it.

For:

var sample = "foo";
var statement = false;
sample = statement ? "bar";

You are asking for the compiler to process the expression, statement ? "bar" in the context of what is going to happen to it: in this case be assigned to sample, and thus throw away the entire statement and replace it with sample = statement ? "bar" : sample. But when the expression isn't used for an assignment, eg with:

var sample = "foo";
var statement = false;
var newValue = F(statement ? "bar");

Then it must detect that the expression isn't directly assigned and so it then has to turn the last line into var newValue = F(statement ? "bar" : default(string);

The compiler doesn't work like that, at all, currently. It never considers what is going to happen to an expression when working out how to compile that expression. This would be a significant deviation away from how the compiler currently works. And it would be pointless anyway. There already exists a better way of handling such assignments: do not reassign :-

var statement = false;
var sample = statement ? "foo" : "bar";

If you can't use that, then there is a clear indication that your code is too complex and needs rationalising.

[aloisdg]

@DavidArno Ok. So lot of works for almost no benefits. Get it :)

[NiklasRaab]

@DavidArno @aloisdg @ig-sinicyn But back to the beginning:

T value = someBool ? <some T value> : default(T);

This should not be complicated to implement and sometimes it would be a nice feature.
Or better:

object value = someBool ? <some T value> : default(T);

[HaloFour]

@NiklasRaab

I believe that the syntax itself would also be ambiguous. You can currently nest ternary conditional operators and the compiler can parse those expressions since every ? must match with a :. But if the : were to be optional the compiler could not make such a correlation.

[GeraudFabien]

Maybe i'm wrong but I feel like it useless if it's only to put default(T) on the varible when false. Because i don't see the problem to add ": null" to your stament. But if it should keep the old value that better because you sometime can't do (and other time don't want to do) (myVar = myBool ? other : myVar). The form with if(){} can use 7 More line

/* Line before one line comment */
// My block comment
if(myBool)
{
   myVar = other;
}
// Close block skip one line

Or if you agree whith no bracket (+3 line)

/* Line before one line comment */
if(myBool)
   myVar = other;
// Close block skip one line (Also protect bug)

[Jijjy]

I found myself wanting this in MVC, something like this seems like it would be pretty convenient:
<div class="@(Model.IsButton ? "btn")"></div>

Also, if you wanted to invert this you could do var foo = bar ?: "hello"

@HaloFour if no matching : is found after any ? all you do is append : default(T) to what's immediately after the ? you're checking. I doubt there would be any major issues with nested expressions, but I don't know how it's currently implemented.

[asmarkis]

Just wanted to chime in on a little old discussion to share another possible use case that for a feature like this, but if not feasible is understandable.

Currently, if you are assigning a value by attempting to parse if from a string, you can do it with one line:
int value = int.TryParse(stringValue, out value) ? value : 42;
Almost equivalent of:

int value;
if (!int.TryParse(stringValue, out value))
value = 42;

With this kind of feature, would it be possible to shorthand this further? Like so?
int value = int.TryParse(stringValue, out value) ?: 42;
Or:
int value = !int.TryParse(stringValue, out value) ? 42;

Therefore it would only assign 42 if the condition from the TryParse is false, but may be tricky with the other scenario where the condition is not met in an assignment. Very minor reduction of redundant code, but thought I'd add this scenario to the discussion anyway. In fact, this may have ended up as more of a proposal to enhance TryParse to assign a value of type T if the parse fails.

[Trayani]

I like the general idea of simplifying the if( expression) , but most of suggested use-cases are related to field initialization which is a pretty bad place for such a thing IMO.
I'd prefer it to act like if-true-statement-else-nothing! (also possible use with a block statement).
if + parenthesis could be replaced with a simple operator. Perhaps like this:

bool-expression => statement
or
bool-expression: statement

Example:

string returnValue = null;
true => returnValue = "this is a return value";
false=>  returnValue = "this never happens";

[filimonic]

Looking for it as if (expression) { .. } shortening for simplyfying arrow functions.

    class ADGroup
    {
        private SecurityIdentifier _sid;
        
        public void UpdateMembers() 
            => !_sid.IsWellKnown(WellKnownSidType.WorldSid) ? UpdateMembersInternal();
            
        private void UpdateMembersInternal()
        {...}
    }