Use Enum’s with caution

In C# the class Enum is often used. Some geek’s argue that the Enum’s “improve code clarity and and reduce the probability of invalid values. … Enum’s are self-documenting.

Enum’s should be used with caution, since some things are not straight-forward. The following article will show you where to be cautious.

What the MSDN documentation says about enum’s:

“The enum keyword is used to declare an enumeration, a distinct type that consists of a set of named constants called the enumerator list. Every enumeration type has an underlying type, which can be any integral type except char. The default underlying type of the enumeration elements is int. By default, the first enumerator has the value 0, and the value of each successive enumerator is increased by 1. For example:”

Enum as a Different Type than Integer

internal enum Color : short
Why would I define an enum as short, UInt32 or as Byte? I believe this is a legacy thing because the enum is mostly used to define the values for the Win32 API.
Using Enum as Flags
[Flags]
internal enum ParseFlags
{
  HaveYear  = 0x00000001,
  HaveMonth = 0x00000002,
  HaveDay  = 0x00000004
}
If you are using enum as Flags, make sure you only use values as the power of 2 only. That will not be enforced and leads to errors when you define for example a value of 3 in the example above.
Enum does not provide Type Safety
If you think enum’s are type safe, you will get into deep trouble. Look at the example code below. The enum that we have defined is 1, 2 and 3. Right?

Now try to call
new EnumTricks.IsVolumeHigh((Volume)27);
That should fail, at least at runtime. It didn’t? That’s really strange… The wrong call will not be detected during compilation nor during runtime. You feel yourself in a false safety.
public enum Volume
{
  Low = 1,
  Medium,
  High
}

public class EnumTricks
{

  public bool IsVolumeHigh(Volume volume)
  {
    var result = false;

    switch (volume)
    {
      case Volume.Low:
        Console.WriteLine("Volume is low.");
        break;

      case Volume.Medium:
        Console.WriteLine("Volume is medium.");
        break;

      case Volume.High:
        Console.WriteLine("Volume is high.");
        result = true;
        break;
    }

    return result;
  }
}
Workaround: Use Enum.IsDefined to find out, if the int value is in the defined range of the enum value.
Enum Conversion
Have you ever tried to convert from enum to int, int to enum, string to enum, string to int value of enum? I’ll show you here with the Volume enum from above, but I didn’t check for the:
public int EnumToInt(Volume volume)
{
  return (int)volume;
}

public Volume IntToEnum(int intValue)
{
  return (Volume)intValue;
}

public Volume StringToEnum(string stringValue)
{
  return (Volume)Enum.Parse(typeof(Volume), stringValue);
}

public int StringToInt(string stringValue)
{
  var volume = StringToEnum(stringValue);
  return EnumToInt(volume);
}
Enum’s have a low Extensibility
Whenever you need integer values to be extensible, don’t choose enum for that. The reason is that you need to change the code to extend the enum. An example of extensible reference values are zip codes. They change and extend frequently.
Solution: One alternative solution is the usage of reference codes. With reference codes you have a code (your identifier) and a value that you will use to show to the user. For example the currencies as defined in the ISO standard define a classical reference code. The list of possible values can be stored in the database or in a file, which both are easy to extend and update.
How to use Enum’s?
What are the enum’s used for in real projects? Often they are used to control the behavior of methods within classes.
public enum Configuration
{
  Debug,
  Release
}

public class Logger
{
  public void Log(Configuration configuration, string logMessage)
  {
    switch (configuration)
    {
      Debug:
        InternalLog("DEBUG: " + logMessage);
        break;

      Release:
        InternalLog(logMessage);
        break;
    }
  }

  private void InternalLog(string logMessage)
  {
    ...
  }

}
This could easily be rewritten (I leave it to you as an exercise to fully implement the example):
public class DebugLogger : AbstractLogger
{
  ...
}

public class ReleaseLogger : AbstractLogger
{
  ...
}
Good choice of Enum’s?
Every time you have a fixed list of integer values which are not used to control your flow of instructions, you may use an enum. We could discuss the usage for the gender (Male, Female, Undefined) or for month of the year (January, February … December). But with the last example I already have the bad feeling of internationalization. Will the string representation of the enum represent the key for the resources?
Conclusion
Whenever you use enum’s please use them with caution and a clear goal in mind. Many developers will use you code at some point in time and they might not be aware of the strange things in enum’s.
See also Urs Enzler’s article about Top 10 of Software Design Evilness.


                        
                            
.NET C# Coding Development Enum