Enumeration types (C# Programming Guide)

An enumeration type (also named an enumeration or an enum) provides an efficient way to define a set of named integral constants that may be assigned to a variable. For example, assume that you have to define a variable whose value will represent a day of the week. There are only seven meaningful values which that variable will ever store. To define those values, you can use an enumeration type, which is declared by using the enum keyword.

enum Day { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
enum Month : byte { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec };


By default the underlying type of each element in the enum is int. You can specify another integral numeric type by using a colon, as shown in the previous example. For a full list of possible types, see enum (C# Reference).

You can verify the underlying numeric values by casting to the underlying type, as the following example shows.

Day today = Day.Monday;
int dayNumber =(int)today;
Console.WriteLine("{0} is day number #{1}.", today, dayNumber);

Month thisMonth = Month.Dec;
byte monthNumber = (byte)thisMonth;
Console.WriteLine("{0} is month number #{1}.", thisMonth, monthNumber);

// Output:
// Monday is day number #1.
// Dec is month number #11.


The following are advantages of using an enum instead of a numeric type:

• You clearly specify for client code which values are valid for the variable.

• In Visual Studio, IntelliSense lists the defined values.

When you do not specify values for the elements in the enumerator list, the values are automatically incremented by 1. In the previous example, Day.Sunday has a value of 0, Day.Monday has a value of 1, and so on. When you create a new Day object, it will have a default value of Day.Sunday (0) if you do not explicitly assign it a value. When you create an enum, select the most logical default value and give it a value of zero. That will cause all enums to have that default value if they are not explicitly assigned a value when they are created.

If the variable meetingDay is of type Day, then (without an explicit cast) you can only assign it one of the values defined by Day. And if the meeting day changes, you can assign a new value from Day to meetingDay:

Day meetingDay = Day.Monday;
//...
meetingDay = Day.Friday;


Note

It's possible to assign any arbitrary integer value to meetingDay. For example, this line of code does not produce an error: meetingDay = (Day) 42. However, you should not do this because the implicit expectation is that an enum variable will only hold one of the values defined by the enum. To assign an arbitrary value to a variable of an enumeration type is to introduce a high risk for errors.

You can assign any values to the elements in the enumerator list of an enumeration type, and you can also use computed values:

enum MachineState
{
PowerOff = 0,
Running = 5,
Sleeping = 10,
Hibernating = Sleeping + 5
}


Enumeration types as bit flags

You can use an enumeration type to define bit flags, which enables an instance of the enumeration type to store any combination of the values that are defined in the enumerator list. (Of course, some combinations may not be meaningful or allowed in your program code.)

You create a bit flags enum by applying the System.FlagsAttribute attribute and defining the values appropriately so that AND, OR, NOT and XOR bitwise operations can be performed on them. In a bit flags enum, include a named constant with a value of zero that means "no flags are set." Do not give a flag a value of zero if it does not mean "no flags are set".

In the following example, another version of the Day enum, which is named Days, is defined. Days has the Flags attribute, and each value is assigned the next greater power of 2. This enables you to create a Days variable whose value is Days.Tuesday | Days.Thursday.

[Flags]
enum Days
{
None      = 0b_0000_0000, // 0
Sunday    = 0b_0000_0001, // 1
Monday    = 0b_0000_0010, // 2
Tuesday   = 0b_0000_0100, // 4
Wednesday = 0b_0000_1000, // 8
Thursday  = 0b_0001_0000, // 16
Friday    = 0b_0010_0000, // 32
Saturday  = 0b_0100_0000  // 64
}
class MyClass
{
Days meetingDays = Days.Tuesday | Days.Thursday;
}


To set a flag on an enum, use the bitwise OR operator as shown in the following example:

// Initialize with two flags using bitwise OR.
meetingDays = Days.Tuesday | Days.Thursday;

// Set an additional flag using bitwise OR.
meetingDays = meetingDays | Days.Friday;

Console.WriteLine($"Meeting days are {meetingDays}"); // Output: Meeting days are Tuesday, Thursday, Friday // Toggle a flag using bitwise XOR. meetingDays = meetingDays ^ Days.Tuesday; Console.WriteLine($"Meeting days are {meetingDays}");
// Output: Meeting days are Thursday, Friday


To determine whether a specific flag is set, use a bitwise AND operation, as shown in the following example:

// Test value of flags using bitwise AND.
bool test = (meetingDays & Days.Thursday) == Days.Thursday;
Console.WriteLine(\$"Thursday {test == true ? "is" : "is not"} a meeting day.");
// Output: Thursday is a meeting day.


For more information about what to consider when you define enumeration types with the System.FlagsAttribute attribute, see System.Enum.

Using the System.Enum methods to discover and manipulate enum values

All enums are instances of the System.Enum type. You cannot derive new classes from System.Enum, but you can use its methods to discover information about and manipulate values in an enum instance.

string s = Enum.GetName(typeof(Day), 4);
Console.WriteLine(s);

Console.WriteLine("The values of the Day Enum are:");
foreach (int i in Enum.GetValues(typeof(Day)))
Console.WriteLine(i);

Console.WriteLine("The names of the Day Enum are:");
foreach (string str in Enum.GetNames(typeof(Day)))
Console.WriteLine(str);


You can also create a new method for an enum by using an extension method. For more information, see How to: Create a New Method for an Enumeration.