Validate Enum Values

Question

I need to validate an integer to know if is a valid enum value.

What is the best way to do this in C#?

Answer 1

You got to love these folk who assume that data not only always comes from a UI, but a UI within your control!

IsDefined is fine for most scenarios, you could start with:

public static bool TryParseEnum<TEnum>(this int enumValue, out TEnum retVal) {  retVal = default(TEnum);  bool success = Enum.IsDefined(typeof(TEnum), enumValue);  if (success)  {   retVal = (TEnum)Enum.ToObject(typeof(TEnum), enumValue);  }  return success; } 

(Obviously just drop the ‘this’ if you don’t think it’s a suitable int extension)

Answer 2

IMHO the post marked as the answer is incorrect.
Parameter and data validation is one of the things that was drilled into me decades ago.

WHY

Validation is required because essentially any integer value can be assigned to an enum without throwing an error.
I spent many days researching C# enum validation because it is a necessary function in many cases.

WHERE

The main purpose in enum validation for me is in validating data read from a file: you never know if the file has been corrupted, or was modified externally, or was hacked on purpose.
And with enum validation of application data pasted from the clipboard: you never know if the user has edited the clipboard contents.

That said, I spent days researching and testing many methods including profiling the performance of every method I could find or design.

Making calls into anything in System.Enum is so slow that it was a noticeable performance penalty on functions that contained hundreds or thousands of objects that had one or more enums in their properties that had to be validated for bounds.

Bottom line, stay away from everything in the System.Enum class when validating enum values, it is dreadfully slow.

RESULT

The method that I currently use for enum validation will probably draw rolling eyes from many programmers here, but it is imho the least evil for my specific application design.

I define one or two constants that are the upper and (optionally) lower bounds of the enum, and use them in a pair of if() statements for validation.
One downside is that you must be sure to update the constants if you change the enum.
This method also only works if the enum is an "auto" style where each enum element is an incremental integer value such as 0,1,2,3,4,.... It won't work properly with Flags or enums that have values that are not incremental.

Also note that this method is almost as fast as regular if "<" ">" on regular int32s (which scored 38,000 ticks on my tests).

For example:

public const MyEnum MYENUM_MINIMUM = MyEnum.One; public const MyEnum MYENUM_MAXIMUM = MyEnum.Four;  public enum MyEnum {     One,     Two,     Three,     Four };  public static MyEnum Validate(MyEnum value) {     if (value < MYENUM_MINIMUM) { return MYENUM_MINIMUM; }     if (value > MYENUM_MAXIMUM) { return MYENUM_MAXIMUM; }     return value; } 

PERFORMANCE

For those who are interested, I profiled the following variations on an enum validation, and here are the results.

The profiling was performed on release compile in a loop of one million times on each method with a random integer input value. Each test was ran more than 10 times and averaged. The tick results include the total time to execute which will include the random number generation etc. but those will be constant across the tests. 1 tick = 10ns.

Note that the code here isn't the complete test code, it is only the basic enum validation method. There were also a lot of additional variations on these that were tested, and all of them with results similar to those shown here that benched 1,800,000 ticks.

Listed slowest to fastest with rounded results, hopefully no typos.

Bounds determined in Method = 13,600,000 ticks

public static T Clamp<T>(T value) {     int minimum = Enum.GetValues(typeof(T)).GetLowerBound(0);     int maximum = Enum.GetValues(typeof(T)).GetUpperBound(0);      if (Convert.ToInt32(value) < minimum) { return (T)Enum.ToObject(typeof(T), minimum); }     if (Convert.ToInt32(value) > maximum) { return (T)Enum.ToObject(typeof(T), maximum); }     return value; } 

Enum.IsDefined = 1,800,000 ticks
Note: this code version doesn't clamp to Min/Max but returns Default if out of bounds.

public static T ValidateItem<T>(T eEnumItem) {     if (Enum.IsDefined(typeof(T), eEnumItem) == true)         return eEnumItem;     else         return default(T); } 

System.Enum Convert Int32 with casts = 1,800,000 ticks

public static Enum Clamp(this Enum value, Enum minimum, Enum maximum) {     if (Convert.ToInt32(value) < Convert.ToInt32(minimum)) { return minimum; }     if (Convert.ToInt32(value) > Convert.ToInt32(maximum)) { return maximum; }     return value; } 

if() Min/Max Constants = 43,000 ticks = the winner by 42x and 316x faster.

public static MyEnum Clamp(MyEnum value) {     if (value < MYENUM_MINIMUM) { return MYENUM_MINIMUM; }     if (value > MYENUM_MAXIMUM) { return MYENUM_MAXIMUM; }     return value; } 

-eol-