Enums and Constants. Which to use when?

Question

I was doing some reading on enums and find them very similar to declaring constants. How would I know when to use a constant rather than an enum or vice versa. What are some of the advantages of using enums?

Answer 1

Use enums when you want to define a range of values that something can be. Colour is an obvious example like:

public enum Colour {     White,     Red,     Blue } 

Or maybe a set of possible things like: (Example I stole from here as I'm lazy)

[FlagsAttribute] enum DistributedChannel {   None = 0,   Transacted = 1,   Queued = 2,   Encrypted = 4,   Persisted = 16,   FaultTolerant = Transacted | Queued | Persisted } 

Constants should be for a single value, like PI. There isn't a range of PI values, there is just PI.

Other points to consider are:

• a: Constants don't necessarily indicate a relationship between the constants, whereas an enumeration indicates that something can be one of the set defined by the enum.
• b: A defined enumeration can help you with type checking when used as an argument. Constants are just values, so they don't provide any additional semantic information.

Answer 2

What's missing from the other answers is that enums have an integer base type. You can change the default from int to any other integral type except char like:

enum LongEnum : long {     foo,     bar, } 

You can cast explicitly from and implicitly to the the base type, which is useful in switch-statements. Beware that one can cast any value of the base type to an enum, even if the enum has no member with the appropriate value. So using always the default section in a switch is a good idea. BTW, .NET itself allows even floating point valued enums, but you can't define them in C#, although I think you can still use them (except in switch).

Furthermore, using enums gives you more type safety. If you intend to use e.g. int constants as method parameters, then I could call the method with any int value. Granted, via casting it can happen with enums, too, but it won't happen accidentally. Worse is the possibility to confuse the order of parameters.

void method(int a, int b) {...} 

If constant A only may go into a and constant B only may go into b, then using two different enum types will uncover any misuse during the compilation.