Discussion: testing for multiple enum values

[jcouv]

@danmosemsft commented on Thu Mar 23 2017

@jterry75 commented on Thu Mar 23 2017

I find myself always writing code like:

enum States
{
    On,
    Off,
    InBetween
}

class Example
{
    public States State { get; }
}

class Program
{
    public static void Main(string[] args)
    {
        var t = new Example();
        // ...
        if (t.State == States.On || t.State == States.InBetween) // <- Interested here.
        {
             // Do something.
        }
    }
}

What if C# had an addition specifically for enum types to match as a language feature.

var t = new Example()
// ...
if (t.State.Is(On, InBetween)
{
    // Do Something
}

I can imagine that this has a few helpful optimizations. For 1 we only need to actually call .State once which means that we know the multiple calls are side-effect-free but for 2 we can actually infer the enum type exactly so we dont need its qualifiers.

enum WowWeWriteExtreemlyDescriptiveEnumNames
{
    A,
    B,
    C
}

var z = WowWeWriteExtremelyDescriptiveEnumNames.A;
// ...
if (z == WowWeWriteExtremelyDescriptiveEnumNames.A || 
    z == WowWeWriteExtremelyDescriptiveEnumNames.B)
{
    // Do Work
}

Goes to

if (z.Is(A, B))
{
    // Do Work
}

You could imagine for [Flags] enums we could match based on logical operation:

[Flags]
enum Test
{
    None = 0x0,
    A = 0x1,
    B = 0x2,
    C = 0x4
}

if (z.Is(A, B || C))
{
    // Do work
}

Ideas?

---

@danmosemsft commented on Thu Mar 23 2017

@jterry75 thanks for the contribution. I'll move to what I think is the right repo
https://github.com/dotnet/roslyn

---

@Korporal commented on Thu Mar 23 2017

This can kind of be achieved now with a little fiddling around:

using System;
using System.Linq;

namespace Junk
{
    public enum Sample
    {
        First,
        Second,
        Third
    }
    class Program
    {
        static void Main(string[] args)
        {
            Sample a = Sample.First;
            Sample b = Sample.Second;
            Sample c = Sample.Third;

            if (b.IsAny(Sample.Third, Sample.Second))
            {
                ;
            }
        }
    }

    public static class EnumExtensions
    {
        public static bool IsAny<T>(this T Enum, params T[] Args) where T : struct, IComparable
        {
            return Args.Where(a => Enum.Equals(a)).Any();
        }
    }

---

@benknoble commented on Thu Mar 23 2017

Note that the solution proposed by @Korporal isn't completely type-safe: it can receive arguments conforming to the where clause (and should still operate as expected), not just enums. We could consider this a feature of the method rather than a bug, but it is notable that the method cannot guarantee T is an enum.

While I don't know that the language needs a feature for this, it raises again the ability to say where T : enum and were there a feature like this, we could get better type-checking (guaranteeing all the parameters are parts of the enum, or things like that).

---

@jcouv commented on Thu Mar 23 2017

The C# language design has moved to a separate repo: https://github.com/dotnet/csharplang
Please move this discussion over there.

---

@jterry75 commented on Fri Mar 24 2017

@Korporal - I do that roughly today but as @benknoble pointed out its kinda a hack. With where T : enum this would certainly be possible but I find it odd that given that constraint we would then require every project to implement the extension method which will just be exactly what you wrote. Seems like the language could just provide this in the System namespace or something.

@jcouv - I dont know how to 'move' an issue but I appreciate the tip on the new repo. Can you assist with the move?

[mstum]

This proposal only mentions enums, but in general I'd like to see some way to apply multiple tests to a variable, e.g., if(str == "foo" or "bar" or "baz") or if(obj.Prop >4 and <9) or similar. (and no, not advocating for and and or keywords, just illustrating the request)

[jnm2]

Related: #316

[louthy]

or if(obj.Prop >4 and <9) or similar.

I think range based expressions would work better as:

    if(4 > obj.Prop > 9) ...

Another Microsoft language called Dafny does this already

The idea is that you can't mix > and <, so you could do:

   x >= y > z

And:

   x < y < z

But not

   x > y < z

[temporaryfile]

I remember Pascal had an "in" operator where you would check set. In C# I imagine it looking a little more like this:

if (5 in { 4, 6, 7 })
{
}

Compiler-optimized checking of multiple values would be huge if you could get it to work.

There are ways of shortening range checking too but they feel like h4x...

public static bool InEnumRange(
   this Enum value,
   Enum lower,
   Enum upper)
{
   if (lower.CompareTo(upper) > 0)
       Swap(ref lower, ref upper);
   return (value.CompareTo(lower) >= 0) && (value.CompareTo(upper) <= 0);
}

[alrz]

Using OR patterns (#118) this can be written like,

 if (t.State is States.On or States.InBetween)

or with #321

 if (t.State is On or InBetween)

(the operator or is just for demonstration)

[StevenRasmussen]

I’m loving these ideas ;). Would be great to have in the next version of C#!