具有相同值的多个枚举

Question

I have a set of constants for which I use an enum in my C# project. In some situations I need just a single value in other situations I need multiple values. I started out with using IEnumerable or a simple array of my enum type to handle multiple values. However I have recently come to need multiple values in an attribute constructor for multiple attributes which I would like to put in a const field of the class.

A simple example:

public enum Browsers {
  Firefox, Chrome, IE, Opera, Safari
}

public class SomeClass {
  [Attr(new Browsers[] { Browsers.Firefox, Browsers.Chrome })]
  public void SomeMethod() { }

  [Attr(new Browsers[] { Browsers.Firefox, Browsers.Chrome })]
  public void SomeOtherMethod() { }
}

I would like to refactor the array of browsers out into a field in the class, however for a field to be used in an attribute constructor it must be a const field and a field with an array initialization cannot be const.

I then tried to use the FlagsAttribute on my enum so that the enum can hold multiple values. I can then make a field private const Browsers = Browsers.Firefox | Browsers.Chrome private const Browsers = Browsers.Firefox | Browsers.Chrome and I'm good. In this situation.

Applying the FlagsAttribute thus allowing for multiple values is not so good in a situation where I need only a single value. In those situations I will always have to first check that the enum has only a single value (I do that by checking if it is a power of 2). I find that a bit annoying. Trading maintainability in one situation for less maintainability in other situations - not ideal.

So my question is is there some smart way to get around this? I thought of making two separate enums one with FlagsAttribute and one without however I will then have to maintain all the values of the enums in two places instead of one. Again not ideal.

Have I missed something that can solve this in a way that does not trade off maintainability anywhere?

UPDATE: What I wanted my code to look like is something like this:

public class SomeClass {
  private const Browsers[] browsers = new Browsers[] { Browsers.Firefox, Browsers.Chrome };

  [Attr(browsers)]
  public void SomeMethod() { }

  [Attr(browsers)]
  public void SomeOtherMethod() { }
}

However that results in a compile error.

An example of a place where I use the enum with a single value only:

public void SomeMethod(Browsers browser) {
  /* When using Flags I need to verify that browser contains only a single value */
  switch(browser)
  {
    case Browsers.Firefox:
      /* do something */
      break;
    case Browsers.Chrome:
      /* do something */
      break;
    /* cases for the rest of the values */
  }

}

My question is: can I somehow create two enums with the same values, one of which has the Flags attribute and the other not having it?

Bonus question: is there a smarter way around this that I am just not seeing?

Answer 1

Multiple enum members may share the same associated value. The example

enum Color 
{
   Red,
   Green,
   Blue,
   Max = Blue
}

shows an enum in which two enum members—Blue and Max—have the same associated value.