Conversion of numeric strings to enum in C#

Question

Recently I've discovered that any string that contains only numeric characters can be converted to enum in C#. For example, imagine there is an enum defined as follows:

public enum TestEnum
{
    One = 1,
    Two = 2,
    Three = 3
};

I can perform a conversion of some random numeric string to TestEnum.

TestEnum testEnum = (TestEnum)Enum.Parse(typeof(TestEnum), "4");
Console.WriteLine(testEnum);

The value '4' of course does not get mapped to one of defined TestEnum values and the output would be just 4, however there would be no error, so this conversion is legal.

On the other hand, if I try to check whether this value defined in TestEnum:

Console.WriteLine(Enum.IsDefined(typeof(TestEnum), "4"));

I would receive False in the output.

This seems a little strange to me, taking into account that the following conversion of non-numeric string, e.g.

(TestEnum)Enum.Parse(typeof(TestEnum), "Test")

will throw System.ArgumentException.

I am confused with such behavior. Was it intentionally designed this way or is this just a coincidence?

Answer 1

Was it intentionally designed this way or is this just a coincidence?

I'm not sure I understand your question. The documentation seems completely clear to me:

Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

(Emphasis mine)

It also says:

If value is the string representation of an integer that does not represent an underlying value of the enumType enumeration, the method returns an enumeration member whose underlying value is value converted to an integral type. If this behavior is undesirable, call the IsDefined method to ensure that a particular string representation of an integer is actually a member of enumType

Clearly this is intentional behavior, and not just coincidental.

Note that you can always cast any value of the enum's underlying type (int in this case), to the enum type itself. The enum type feature does not enforce values of the enum to correspond to named value. So the parsing behavior is entirely consistent with the compile-time behavior of enum types.

I suppose one might debate whether the enum type should allow unnamed values to be used. But, given that one of the features of enum types is to allow for flag-based enums, whether or not they have the [Flags] attribute, and given that it would be inconvenient (to say the least) to have to name every single combination of every single flag one defines in an enum type, it seems reasonable that they would go ahead and allow unnamed values for all types of enum types.