Shorter condition statements

[GerbenVersluis]

We all know the following struggle when writing conditions:

public enum MyEnum
{
   typeA,
   typeB,
   typeC,
   typeD
}

var type = MyEnum.typeA;

if(type != MyEnum.typeB && type != MyEnum.typeC && type != MyEnum.typeD)
{
   // do stuff
}

Writing the type != over and over again feels like duplicated code.
The following would be nicer:
Explanation: condition is true when type IS NOT MyEnum.typeB AND MyEnum.typeC AND MyEnum.typeC

if(type != (MyEnum.typeB && MyEnum.typeC && MyEnum.typeD))
{
    // do stuff
}

This would also work for other types besides enums like such:
Explanation: condition is true when foo is equal to some, random, value or bar

var foo = "bar";

if(foo == ("some" || "random" || "value" || "bar"))
{
     // do stuff
}

It should work for every operator like such:
Explanation: condition is true when foo is greater than limitA AND limitB

var limitA = 5;
var limitB = 10;
var foo = 15;

if(foo > (limitA && limitB))
{
   // do stuff
}

Would this be a welcome feature?
ps: i'm not creative enough to find a fitting title for this 'issue' / 'request'

[HaloFour]

This would break existing code as arbitrary types may already overload the && and || operators.

[ufcpp]

#1350

var foo = "bar";

if (foo is "some" or "random" or "value" or "bar")
{
     // do stuff
}

[AustinBryan]

@ufcpp That is better because it obviously won't be breaking previous code as well as being more closer to English, less parens, and even shorter.

[theunrepentantgeek]

There's greater precedent for syntax along these lines:

public enum MyEnum
{
   typeA,
   typeB,
   typeC,
   typeD
}

var type = MyEnum.typeA;

if(type in (MyEnum.typeB, MyEnum.typeC, MyEnum.typeD))
{
   // do stuff
}

(Inspired by very faded memories of the Delphi enumeration and set syntax)

This avoids the need to overload the meaning of && and || in new and wonderful ways that are very likely to conflict with existing uses, wouldn't break existing code, and doesn't require a new keyword.

But, I'm not sure the language needs this - and I strongly suspect making it work with predictable performance would be challenging.

[tacosontitan]

I'm curious as to what makes you suspect that predictable performance for this would be challenging? I can sort-of see it with the potential need for various types of branch instructions but I'm curious on your thoughts there. I've thought C# needed an IN clause for quite some time now to be fair (and for more than just enumerated types) so I absolutely love this idea!

[jveselka]

I found Flags enums usefull in similar cases:

[Flags]
public enum MyEnum
{
   //meta values
   typeThatShouldNotDoStuff = 1,
   //real values
   typeA = 2,
   typeB = 4 | typeThatShouldNotDoStuff,
   typeC = 8 | typeThatShouldNotDoStuff,
   typeD = 16 | typeThatShouldNotDoStuff
}

var type = MyEnum.typeA;

if(!type.HasFlag(MyEnum.typeThatShouldNotDoStuff))
{
   // do stuff
}

It will look much nicer once you assign good semantic names to enum values.

[YairHalberstadt]

with and, or, not, > and < patterns, this is all possible in C# 9:

if(type is not (MyEnum.typeB or MyEnum.typeC or MyEnum.typeD))
{
    // do stuff
}

if(foo is "some" or "random" or "value" or "bar")
{
     // do stuff
}

const int limitA = 5;
const int limitB = 10;
var foo = 15;

if(foo is > limitA and > limitB)
{
   // do stuff
}

However it is limited to only work on constants.

[tacosontitan]

However it is limited to only work on constants.

That's a start though right?

[spydacarnage]

I use a bool IsOneOf<T>(this T @this, params T[] values) extension method for this (and still will, for when non-constant values are needed)