Enums and flag enums

(TrainClass)7 compiles and runs in C#, although TrainClass names only four classes of ticket, numbered 1 to 4: the program prints 7 and carries on. Enumsenum: A value type that gives names to constants of an integer type, int unless the declaration names another. Any number of that type converts to the enum, whether a member names it or not. give names to numbers, and every number of the enum’s integer type is a value of it, named or not. A flags enumflags enum: An enum marked [Flags] whose members are powers of two, so each owns one bit and | combines several in one value. ToString names every set bit, such as Window, Lower. gives each option one bit, so one value can hold several options at once.

You will define enums with explicit numbers, combine options in flag enums, read an enum from text without letting a 7 through, and handle the values that no member names.

An enum names numbers, and every number of its type is a value

An enum declares a type whose values are named constants of an integer type, int unless you choose another. That integer type is the enum’s underlying typeunderlying type: The integer type that an enum stores its values in: int unless the declaration names another, as in enum Berth : byte. It decides the size of a value and the numbers it can hold.: it sets the size of each value and the numbers it can hold. Writing each number yourself, as a database or an API stores it, keeps the numbers fixed when members are added later:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// The class of a train ticket, with the number a booking system stores for each.
TrainClass chosen = TrainClass.AC3;
Console.WriteLine($"{chosen} is stored as {(int)chosen}");
Console.WriteLine($"(TrainClass)4 is {(TrainClass)4}");

// Any int converts to the enum, named or not.
TrainClass unknown = (TrainClass)7;
Console.WriteLine($"(TrainClass)7 prints as {unknown}, defined: {Enum.IsDefined(unknown)}");

TrainClass fresh = default;
Console.WriteLine($"default(TrainClass) prints as {fresh}, defined: {Enum.IsDefined(fresh)}");

Console.WriteLine($"members: {string.Join(", ", Enum.GetValues<TrainClass>().Select(c => $"{c} = {(int)c}"))}");
Console.WriteLine($"AC3 < AC2: {TrainClass.AC3 < TrainClass.AC2}, AC3 + 1 = {TrainClass.AC3 + 1}");
Console.WriteLine($"underlying type: {Enum.GetUnderlyingType(typeof(TrainClass)).Name}");

enum TrainClass
{
    Sleeper = 1,
    AC3 = 2,
    AC2 = 3,
    AC1 = 4,
}

AC3 is stored as 2
(TrainClass)4 is AC1
(TrainClass)7 prints as 7, defined: False
default(TrainClass) prints as 0, defined: False
members: Sleeper = 1, AC3 = 2, AC2 = 3, AC1 = 4
AC3 < AC2: True, AC3 + 1 = AC2
underlying type: Int32

(int)chosen gave 2, the number a booking system would store for AC3, and (TrainClass)4 gave AC1 back: explicit casts convert both ways. (TrainClass)7 was accepted as well and printed as 7, because any int converts to the enum, and only Enum.IsDefined said that no member has the value. The default is 0 although no member has it, and Microsoft’s reference advises almost always defining a member with the value 0, such as None or Unknown, so that a new variable means something. Underneath, enums stay numbers: AC3 < AC2 compared 2 with 3, and AC3 + 1 gave AC2.

A flags enum gives every option its own bit

Some choices combine: a passenger may want a window and a lower berth. Flag enums give each option a power of two, so each owns one bit and | combines any set of them in one value. The [Flags] attribute tells .NET that values are combinations, and ToString names each option they hold:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// Seat preferences: each option owns one bit, so any set of them fits in one value.
SeatPreference wanted = SeatPreference.Window | SeatPreference.Lower;
Console.WriteLine($"Window | Lower = {wanted} ({(int)wanted}, bits {Bits(wanted)})");
Console.WriteLine($"HasFlag(Lower) {wanted.HasFlag(SeatPreference.Lower)}, HasFlag(Aisle) {wanted.HasFlag(SeatPreference.Aisle)}");

wanted |= SeatPreference.Side;
Console.WriteLine($"after |= Side:    {wanted} (bits {Bits(wanted)})");
wanted &= ~SeatPreference.Window;
Console.WriteLine($"after &= ~Window: {wanted} (bits {Bits(wanted)})");

Console.WriteLine($"None = {SeatPreference.None}, Lower | Upper = {SeatPreference.Lower | SeatPreference.Upper}");
Console.WriteLine($"(SeatPreference)13 = {(SeatPreference)13}");
Console.WriteLine($"(SeatPreference)64 = {(SeatPreference)64}, (SeatPreference)69 = {(SeatPreference)69}");

// The same numbers in an enum without [Flags] print as numbers.
Console.WriteLine($"without [Flags], 5 = {(PlainPreference)5}");

// A [Flags] enum of .NET itself: Unix file permissions, 755 in octal.
UnixFileMode mode = (UnixFileMode)Convert.ToInt32("755", 8);
Console.WriteLine($"755 = {mode}");

static string Bits(SeatPreference p) => Convert.ToString((int)p, 2).PadLeft(5, '0');

[Flags]
enum SeatPreference
{
    None = 0,
    Window = 1,
    Aisle = 2,
    Lower = 4,
    Upper = 8,
    Side = 16,
    AnyBerth = Lower | Upper,
}

enum PlainPreference
{
    None = 0,
    Window = 1,
    Aisle = 2,
    Lower = 4,
    Upper = 8,
    Side = 16,
}

Window | Lower = Window, Lower (5, bits 00101)
HasFlag(Lower) True, HasFlag(Aisle) False
after |= Side:    Window, Lower, Side (bits 10101)
after &= ~Window: Lower, Side (bits 10100)
None = None, Lower | Upper = AnyBerth
(SeatPreference)13 = Window, AnyBerth
(SeatPreference)64 = 64, (SeatPreference)69 = 69
without [Flags], 5 = 5
755 = OtherExecute, OtherRead, GroupExecute, GroupRead, UserExecute, UserWrite, UserRead

Window | Lower printed as Window, Lower, the value 5, bits 00101. HasFlag tested one option, |= added Side and &= ~ removed Window, the same bit operators that the operators lesson used on plain integers. None names zero, and a member can name a combination: AnyBerth is Lower | Upper. Step through how each value became text:

A bit that no member names makes the whole value print as a number, 64 and 69, and without [Flags] the same 5 printed as 5. .NET uses the same design for its own options: UnixFileMode printed 755 as the names of the seven permission bits it sets.

Enum.TryParse reads names, and numbers too

Text from a form or a file has to become an enum value. Enum.TryParse reads a member’s name, ignoring case when you ask, and returns false for a name it does not know:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// Eight texts a form might send, read with Enum.TryParse, ignoring case.
string[] inputs = ["AC3", "ac3", " AC2 ", "Sleeper, AC1", "7", "-1", "AC4", ""];
Console.WriteLine($"{"input",-16} {"TryParse",-15} IsDefined");
foreach (string input in inputs)
{
    bool parsed = Enum.TryParse(input, ignoreCase: true, out TrainClass value);
    string defined = parsed ? Enum.IsDefined(value).ToString() : "-";
    Console.WriteLine($"{$"\"{input}\"",-16} {$"{parsed}, {value}",-15} {defined}");
}

bool exactCase = Enum.TryParse("ac3", out TrainClass _);
Console.WriteLine($"without ignoreCase, \"ac3\" gives {exactCase}");

enum TrainClass
{
    Sleeper = 1,
    AC3 = 2,
    AC2 = 3,
    AC1 = 4,
}

input            TryParse        IsDefined
"AC3"            True, AC3       True
"ac3"            True, AC3       True
" AC2 "          True, AC2       True
"Sleeper, AC1"   True, 5         False
"7"              True, 7         False
"-1"             True, -1        False
"AC4"            False, 0        -
""               False, 0        -
without ignoreCase, "ac3" gives False

ac3 and " AC2 ", with its spaces, were read. Three results need a second look: 7 and -1 were accepted as numbers, and Sleeper, AC1 as a list combined into 5, although TrainClass is not a flags enum. Microsoft’s documentation of TryParse describes both: a list is combined with a bitwise OR, and text that is a number becomes that number even when no member has it. Follow four of the inputs through the two checks:

Validating enum input, with every trap of TryParse reproduced Pro: opens with a Pro, Premium or Ultimate pass

Switch expressions over enums: CS8509, CS8524 and the discard arm Pro: opens with a Pro, Premium or Ultimate pass

Enums over time: stored numbers, JSON and members of their own Pro: opens with a Pro, Premium or Ultimate pass

Practise: add a member and predict the text

Then test yourself on enum values, flags and parsing; the questions follow your answers, and a wrong choice tells you what it missed:

Interview questions

Fresher · What is a [Flags] enum, and how is it different from an ordinary enum?

An ordinary enum names values that exclude each other, such as the one class of a ticket. A [Flags] enum names options that combine: each member is a power of two, so each owns one bit, and | stores any set of them in one value, such as Window | Lower, which is 5. The attribute changes how a value prints: ToString names every option it holds, Window, Lower, where an ordinary enum would print 5. Test an option with HasFlag or (value & option) != 0, and define None = 0 for the empty set.

Key takeaways

• An enum gives names to the numbers of an integer type, and any number of that type is a value of the enum, so (TrainClass)7 compiles and prints 7.
• Flag enums give every option one bit, | combines options, and [Flags] makes ToString name each one.
• Enum.TryParse reads names, numbers and comma-separated lists, so parsed input still needs a check that its value has a name.
• Check enum values where they enter the program, because a cast, a stored number and parsed text never check them.