Getting item names from enums with multiple zero values

Question

I'm having difficulties working with some legacy enums that have multiple zero values. Whenever I call ToString on one of the non-zero values, all but the first zero value is included.

Is there any way to isolate the non-zero value name without resorting to string manipulation or reflection?

Click to copy

//all of the following output "Nada, Zilch, One"
Console.WriteLine(TestEnum.One);
Console.WriteLine(Convert.ToString(TestEnum.One));
Console.WriteLine(TypeDescriptor.GetConverter(typeof(TestEnum))
                      .ConvertToString(TestEnum.One));

[Flags]
enum TestEnum
{
    Zero = 0,
    Nada = 0,
    Zilch = 0,
    One = 1
}

Edit

I understand that having multiple items with the same value is not recommended however the enum in question is defined in a legacy assembly that I can't change. In fact, there are 12 public enums in mscorlib v4 that break this recommendation, as determined by the following simple LINQ query:

Click to copy

var types = typeof (void).Assembly.GetTypes()
    .Where(type => type.IsEnum &&
                   type.IsPublic &&
                   Enum.GetValues(type).Cast<object>()
                       .GroupBy(value => value)
                       .Any(grp => grp.Count() > 1))
    .ToList();

Answer 1

Here is one option. It works, but it's a bit ugly. The values / names variables won't change, so they only need to be calculated once.

Assuming you have a slightly more complicated enum, such as:

Click to copy

[Flags]
public enum TestEnum
{
    Zero = 0,
    Nada = 0,
    Zilch = 0,
    One = 1,
    Two = 2,
    Three = 3,
    Four = 4
}

Here is some code you could use:

Click to copy

var input = TestEnum.One | TestEnum.Two;
var values = (TestEnum[]) Enum.GetValues(typeof (TestEnum));
var names = Enum.GetNames(typeof (TestEnum));
var result = values
    .Select((value, index) =>
            input == value || (value != 0 && (input & value) == value)
                ? names[index]
                : null)
    .Where(name => name != null);
var text = string.Join(", ", result);
Console.WriteLine(text);

Answer 2

Alright, first Microsoft recommends against this strongly. Some of the stronger words I've heard them use for something they don't enforce on compile:

Avoid setting a flags enumeration value to zero, unless the value is used to indicate that all flags are cleared. Such a value should be named appropriately as described in the next guideline... Do name the zero value of flags enumerations None. For a flags enumeration, the value must always mean all flags are cleared.

Ok, so why is this happening? From this question I take it's Enum.ToString behaving strangely:

If multiple enumeration members have the same underlying value and you attempt to retrieve the string representation of an enumeration member's name based on its underlying value, your code should not make any assumptions about which name the method will return.

EDIT: I'm able to reproduce your results, but I can't find any more documentation on why it would start printing out the other 0 values. I would expect it to print NONE of them.

Can you just right-click->refactor->rename them all the same and then delete the others? It seems easier and less against what Microsoft recommends.