C# - Enum

Enum (Enumeration) in C#

In C#, enum (short for enumeration) is a special value type that allows a variable to be one of a set of predefined named constants. Enums provide a convenient way to work with sets of related constants and improve code readability and maintainability.

Introduction to Enum

An enumeration defines a set of named integral constants that help make programs more readable and manageable. Instead of using magic numbers or string literals, enums let you assign meaningful names to constant values.

enum DaysOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

Here, DaysOfWeek is an enumeration that represents the days of the week. Internally, each member is assigned an integral value starting from 0 by default.

Why Use Enums?

• Code Readability: Named constants improve code clarity compared to using raw numeric or string values.
• Maintainability: If you need to change a value, you can do so in one place.
• Type Safety: Enums restrict variable values to the predefined set, reducing errors.
• IntelliSense Support: IDEs provide auto-completion for enum values.

Basic Syntax of Enums

The basic syntax to declare an enum in C# is:

enum EnumName
{
    Member1,
    Member2,
    Member3,
    ...
}

By default, the underlying type of the enum members is int, and members start at 0, incrementing by 1 automatically.

Example: Simple Enum Declaration

enum Colors
{
    Red,    // 0
    Green,  // 1
    Blue    // 2
}

In this example, Red has the value 0, Green 1, and Blue 2.

Enum Underlying Types

By default, the underlying type of enum members is int. However, you can specify another integral numeric type: byte, sbyte, short, ushort, int, uint, long, or ulong.

enum ErrorCode : byte
{
    None = 0,
    NotFound = 1,
    ServerError = 255
}

Using a smaller underlying type can save memory if the enum is used extensively and the range of values fits in that type.

Rules for Enum Underlying Types

• The underlying type must be an integral type.
• If unspecified, the default underlying type is int.
• All enum members must be constants within the underlying type’s range.

Assigning Values to Enum Members

You can explicitly assign values to enum members. Members without assigned values will continue counting from the previous member’s value.

enum Status
{
    Unknown = 0,
    Started = 1,
    InProgress = 5,
    Completed,      // 6 (automatically next integer)
    Cancelled = 10,
    Failed          // 11
}

Here, Completed automatically gets value 6 (one more than 5), and Failed gets 11 (one more than 10).

Working with Enums in C#

Declaring and Using Enums

DaysOfWeek today = DaysOfWeek.Monday;

if (today == DaysOfWeek.Monday)
{
    Console.WriteLine("Start of the work week.");
}

Enums can be used just like any other value type in conditions, switches, and assignments.

Switch Statement with Enums

switch (today)
{
    case DaysOfWeek.Saturday:
    case DaysOfWeek.Sunday:
        Console.WriteLine("It's the weekend!");
        break;
    default:
        Console.WriteLine("It's a weekday.");
        break;
}

Casting Enums

You can cast enum members to their underlying integral value and vice versa.

// Enum to int
int dayValue = (int)DaysOfWeek.Wednesday;  // 3

// Int to Enum
DaysOfWeek day = (DaysOfWeek)3;  // Wednesday

Note that casting an integer that is not defined in the enum is possible but may cause unexpected behavior if not handled carefully.

Enum Methods and Helpers

Using System.Enum Methods

C# provides several static methods in the System.Enum class to work with enums:

• GetNames() - Returns an array of the enum member names as strings.
• GetValues() - Returns an array of the enum member values.
• IsDefined() - Checks if a value or name is defined in the enum.
• Parse() and TryParse() - Convert strings to enum values.

Example: Retrieving Enum Names and Values

string[] names = Enum.GetNames(typeof(DaysOfWeek));
foreach (string name in names)
{
    Console.WriteLine(name);
}

Array values = Enum.GetValues(typeof(DaysOfWeek));
foreach (var val in values)
{
    Console.WriteLine(val);
}

Parsing Enums from Strings

string input = "Friday";
if (Enum.TryParse(input, out DaysOfWeek result))
{
    Console.WriteLine($"Parsed successfully: {result}");
}
else
{
    Console.WriteLine("Invalid enum name.");
}

Flags Attribute and Bitwise Enums

Sometimes you want to combine enum values using bitwise operations, for example, when representing multiple options or permissions. The [Flags] attribute in C# allows this.

Defining a Flags Enum

[Flags]
enum FileAccessPermissions
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4,
    ReadWrite = Read | Write,
    All = Read | Write | Execute
}

Using Flags Enums

FileAccessPermissions permissions = FileAccessPermissions.Read | FileAccessPermissions.Write;

if ((permissions & FileAccessPermissions.Read) == FileAccessPermissions.Read)
{
    Console.WriteLine("Read permission granted.");
}

if ((permissions & FileAccessPermissions.Execute) == FileAccessPermissions.Execute)
{
    Console.WriteLine("Execute permission granted.");
}
else
{
    Console.WriteLine("Execute permission denied.");
}

Converting Flags Enum to String

With the [Flags] attribute, calling ToString() on combined enum values will produce a comma-separated string of all active flags.

Console.WriteLine(permissions.ToString());  // Output: Read, Write

Enum Limitations and Considerations

• Enums are value types and cannot be null unless used with nullable types (EnumName?).
• Enums only support integral underlying types, so floating-point or string values are not possible.
• Enum members cannot share the same name but can have the same numeric value.
• By default, enums have no validation for invalid values outside the defined set when cast from integers.

Advanced Enum Features

Using Nullable Enums

Enums can be declared nullable if you need to represent an undefined or unassigned state.

DaysOfWeek? meetingDay = null;

if (!meetingDay.HasValue)
{
    Console.WriteLine("Meeting day not set.");
}

Custom Enum Attributes

You can associate metadata with enum members using custom attributes.

enum Status
{
    [System.ComponentModel.Description("Operation completed successfully")]
    Success = 0,

    [System.ComponentModel.Description("Operation failed due to error")]
    Failure = 1
}

Reflection can then be used to retrieve these descriptions at runtime.

Example: Retrieving Enum Descriptions

using System;
using System.ComponentModel;
using System.Reflection;

public static string GetEnumDescription(Enum value)
{
    FieldInfo fi = value.GetType().GetField(value.ToString());
    DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);

    return attributes.Length > 0 ? attributes[0].Description : value.ToString();
}

Comparison with Constants and Static Classes