The enum keyword is used to declare an enumeration, a distinct type
consisting 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 Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};
In this enumeration, Sat is 0, Sun
is 1, Mon is 2,
and so forth. Enumerators can have initializers to override the default values.
For example:
enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};
In this enumeration, the sequence of elements is forced to start from 1 instead of 0.
A variable of type Days can
be assigned any value in the range of the underlying type; the values are not
limited to the named constants.
The default value of an enum E is the value produced by the
expression (E)0.
The underlying type specifies how much storage is allocated for each
enumerator. However, an explicit cast is needed to convert from enum type
to an integral type. For example, the following statement assigns the
enumerator Sun to a variable of
the type int using a cast to convert from enum to int:
int x = (int)Days.Sun;
When you apply System.FlagsAttribute to an
enumeration that contains some elements combined with a bitwise OR operation,
you will notice that the attribute affects the behavior of the enum when
used with some tools. You can notice these changes when using tools such as the
Console class methods, the Expression Evaluator, and so forth. (See
example 3).
Assigning additional values new versions of enums, or changing the values of
the enum members in a new version, can cause problems for dependant source
code. It is often the case that enum values are used in switch statements,
and if additional elements have been added to the enum type, the test
for default values can return true unexpectedly.
If other developers will be using your code, it is important to provide
guidelines on how their code should react if new elements are added to any enum
types.
In this
example, an enumeration, Days,
is declared. Two enumerators are explicitly converted to integer and assigned
to integer variables.
// keyword_enum.cs
// enum initialization:
using System;
public class EnumTest
{ enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};
static void Main()
{ int x = (int)Days.Sun;
int y = (int)Days.Fri;
Console.WriteLine("Sun = {0}", x); Console.WriteLine("Fri = {0}", y); }
}
Output
Sun = 2
Fri = 7
In this example, the base-type option is used to declare an enum
whose members are of the type long. Notice that even though the
underlying type of the enumeration is long, the enumeration members must
still be explicitly converted to type long using a cast.
// keyword_enum2.cs
// Using long enumerators
using System;
public class EnumTest
{ enum Range :long {Max = 2147483648L, Min = 255L}; static void Main()
{ long x = (long)Range.Max;
long y = (long)Range.Min;
Console.WriteLine("Max = {0}", x); Console.WriteLine("Min = {0}", y); }
}
Output
Max = 2147483648
Min = 255
The following code example illustrates the use and effect of the System.FlagsAttribute
attribute on an enum declaration.
// enumFlags.cs
// Using the FlagsAttribute on enumerations.
using System;
[Flags]
public enum CarOptions
{ SunRoof = 0x01,
Spoiler = 0x02,
FogLights = 0x04,
TintedWindows = 0x08,
}
class FlagTest
{ static void Main()
{ CarOptions options = CarOptions.SunRoof | CarOptions.FogLights;
Console.WriteLine(options);
Console.WriteLine((int)options);
}
}
Output
SunRoof, FogLights
5
Comments
Notice that if you remove the initializer from Sat=1, the result will be:
Sun = 1
Fri = 6
Comments
Notice that if you remove FlagsAttribute,
the example will output the following:
5
5