Proposal: Analog for enums containing multiple options and bitwise operations with them

[Spaier]

Now:

public enum SomeEnum {
    Flag1 = 0b0, Flag2 = 0b1, Flag3 = 0b10
}
public void SomeMethod() {
    SomeEnum options = SomeEnum.Flag1;
    // Add Flag2
    options |= SomeEnum.Flag2;
    if (options & SomeEnum.Flag1) { } // True
    if (options & SomeEnum.Flag3) { } // False
}

Sometimes such code is hard to understand. It would be nice to have a feature to compile multiple booleans or enums into a single enum using some structure. Let's call it cell. Here's how i see it:

public cell SomeOptions {
    bool Flag1,
    bool Flag2,
    bool Flag3
}
public void SomeMethod() {
    SomeOptions options = new SomeOptions();
    options.Flag2 = true;
    if (options.Flag1) { } // True
    if (options.Flag3) { } // False
}

And it would compile into the code above with enum and bitwise operations.

[svick]

I think there are three important dimensions here:

1. Readable and short code to declare the "cell".
2. Readable and short code to use the "cell".
3. Good performance.

What you're proposing satisfies all points (1, 2 and 3).

With current C#, you can satisfy any two points:

• 1 and 2: Create a struct with a bool auto-property for each flag. This is easy to declare and also to use. It might be less efficient, since it requires a whole byte for each flag, but that shouldn't make a significant difference, unless you have many flags.

• 1 and 3: Just use a flags enum.

• 2 and 3: Create a struct that wraps a flags enum and has a bool property for each flag:

  public struct SomeOptions
  {
      [Flags] private enum SomeOptionsEnum : byte
      {
          Flag1 = 0b001, Flag2 = 0b010, Flag3 = 0b100
      }
  
      private SomeOptionsEnum enumValue;
  
      private void SetFlag(SomeOptionsEnum flag, bool isSet)
      {
          if (isSet)
              enumValue |= flag;
          else
              enumValue &= ~flag;
      }
  
      public bool Flag1
      {
          get => enumValue.HasFlag(SomeOptionsEnum.Flag1);
          set => SetFlag(SomeOptionsEnum.Flag1, value);
      }
  
      public bool Flag2
      {
          get => enumValue.HasFlag(SomeOptionsEnum.Flag2);
          set => SetFlag(SomeOptionsEnum.Flag2, value);
      }
  
      public bool Flag3
      {
          get => enumValue.HasFlag(SomeOptionsEnum.Flag3);
          set => SetFlag(SomeOptionsEnum.Flag3, value);
      }
  }

  It's pretty verbose to declare such a type, but the usage is exactly what you want and it should be efficient, since it's using only one bit for each flag.

So, as long as you're willing to sacrifice one of the points, you can get what you want now. Because of that, I don't see adding a whole fundamental type kind to be worth it.

[yaakov-h]

Maybe #107 would solve this?

[AdamSpeight2008]

There is a proposal in VB.net to extend the Dictionary Lookup Operator ! to Enum Flags Operators. I don't know if there is a similar concept in C#.
The prototype it links to is currently in development to at stages it maybe unstable.
In theory it should also be possible constant folding on the enum flags.

[tuespetre]

Although I agree with @svick that adding a new 'kind of type' like that would not be worth it, I do think this could be accomplished by extending the language in another way. Remember how the TupleElementNamesAttribute works? What if the compiler offered similar support for an enum with a FlagsAttribute?

• Gets like e.Flag1 could be rewritten by the compiler as ((e & SomeEnum.Flag1) == SomeEnum.Flag1)
• Sets like e.Flag2 = true could be rewritten by the compiler as e |= SomeEnum.Flag2
• Sets like e.Flag3 = false could be rewritten by the compiler as e &= ~SomeEnum.Flag3

in #1323 I suggested

Flag Color: int
{
    Red,
    Green,
    Blue
}

with this implementation:

        class Color
        {
            public enum ColorEnum : int
            {
                None = 0,
                Red = 1,
                Green = 2,
                Blue = 4
            }

            ColorEnum Value;

            public Color()
            {
                Value = ColorEnum.None;
            }

            public Color(bool red, bool green, bool blue)
            {
                Red = red;
                Green = green;
                Blue = blue;
            }

            public bool Red
            {
                get => (Value & ColorEnum.Red) == ColorEnum.Red;
                set
                {
                    if (value)
                        Value |= ColorEnum.Red;
                    else
                        Value &= ~ColorEnum.Red;
                }
            }

            public bool Green
            {
                get => (Value & ColorEnum.Green) == ColorEnum.Green;
                set
                {
                    if (value)
                        Value |= ColorEnum.Green;
                    else
                        Value &= ~ColorEnum.Green;
                }
            }

            public bool Blue
            {
                get => (Value & ColorEnum.Blue) == ColorEnum.Blue;
                set
                {
                    if (value)
                        Value |= ColorEnum.Blue;
                    else
                        Value &= ~ColorEnum.Blue;
                }
            }

            ColorEnum ToEnum() => Value;
            int ToNumeric() => (int)Value;

            public static implicit operator int(Color color) => (int)color.Value;

            public static implicit operator Color(int value) => new Color() {
                Red = ((int)ColorEnum.Red & value) > 0,
                Green = ((int)ColorEnum.Green & value) > 0,
                Blue = ((int)ColorEnum.Blue & value) > 0
            };

            public static implicit operator ColorEnum(Color color) => color.Value;

            public static implicit operator Color(ColorEnum value) => new Color() {Value =value };

            public static Color operator | (Color color1 , Color color2) => new Color() { Value = color1.ToEnum() | color2.ToEnum() };

            public static Color operator &(Color color1, Color color2) => new Color() { Value = color1.ToEnum() & color2.ToEnum() };

            public static Color operator ~(Color color) => new Color() { Value = ~color.ToEnum() };

            public static Color operator ^(Color color1, Color color2) => new Color() { Value = color1.ToEnum() ^ color2.ToEnum() };

        }