Prev Next

Understanding C# Enums

Enums in C# are used to define a set of named integral constants. Enums make it easier to work with a collection of related constants, such as days of the week, months, or directions. By using enums, you can improve the readability and maintainability of your code, especially when working with related constant values.

Key Topics

What are Enums?

An enum (short for enumeration) in C# is a value type that defines a set of named constants. Enums are useful when you have values that are related and should be grouped together logically. They can be used to assign names to integer values, which improves code clarity.

Example: Enum for Days of the Week

public enum DayOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

class Program
{
    static void Main(string[] args)
    {
        DayOfWeek today = DayOfWeek.Wednesday;
        Console.WriteLine($"Today is {today}");  // Output: Today is Wednesday
    }
}

Output:

Today is Wednesday

Explanation: The enum DayOfWeek defines the days of the week as constants. The variable today is assigned the value DayOfWeek.Wednesday, and the output displays the corresponding day.

Defining Enums

Enums are defined using the enum keyword. Each value in an enum is given an integer value starting from 0, unless otherwise specified. Enums can also be defined with custom underlying types, such as byte, short, or long.

Example: Defining an Enum

public enum Month
{
    January = 1,
    February,
    March,
    April,
    May,
    June,
    July,
    August,
    September,
    October,
    November,
    December
}

class Program
{
    static void Main(string[] args)
    {
        Month currentMonth = Month.October;
        Console.WriteLine($"Current month is {currentMonth}");  // Output: Current month is October
        Console.WriteLine($"Numeric value of {currentMonth} is {(int)currentMonth}");  // Output: Numeric value of October is 10
    }
}

Output:

Current month is October
Numeric value of October is 10

Explanation: The enum Month starts from 1 for January, and the subsequent months are assigned consecutive integer values. The example demonstrates how to retrieve both the name and numeric value of an enum member.

Using Enums in Code

Once defined, enums can be used in code to create variables and assign values from the enum. Enum values can also be compared, printed, or cast to their underlying integer values. Enums provide a way to work with named constants that represent meaningful values in your code.

Example: Using Enums in Switch Statements

public enum TrafficLight
{
    Red,
    Yellow,
    Green
}

class Program
{
    static void Main(string[] args)
    {
        TrafficLight currentLight = TrafficLight.Yellow;

        switch (currentLight)
        {
            case TrafficLight.Red:
                Console.WriteLine("Stop");
                break;
            case TrafficLight.Yellow:
                Console.WriteLine("Get Ready");
                break;
            case TrafficLight.Green:
                Console.WriteLine("Go");
                break;
        }
    }
}

Output:

Get Ready

Explanation: The TrafficLight enum defines the states of a traffic light. The switch statement demonstrates how to handle different enum values, with specific actions based on the value of currentLight.

Methods for Working with Enums

C# provides several built-in methods to work with enums, including Enum.Parse() and Enum.GetValues(). These methods allow you to convert strings to enum values and get all the values in an enum, respectively.

Example: Using Enum Methods

public enum Season
{
    Winter,
    Spring,
    Summer,
    Fall
}

class Program
{
    static void Main(string[] args)
    {
        // Parse a string to get the enum value
        Season season = (Season)Enum.Parse(typeof(Season), "Summer");
        Console.WriteLine(season);  // Output: Summer

        // Get all values from the enum
        Season[] allSeasons = (Season[])Enum.GetValues(typeof(Season));
        foreach (Season s in allSeasons)
        {
            Console.WriteLine(s);
        }
    }
}

Output:

Summer
Winter
Spring
Summer
Fall

Explanation: The method Enum.Parse() converts a string to its corresponding enum value, while Enum.GetValues() retrieves all the values from the enum Season.

Enums with Underlying Types

By default, enums in C# use int as the underlying type. However, you can specify a different underlying type, such as byte, short, or long, if necessary. The underlying type determines the storage size of the enum values.

Example: Enum with a Custom Underlying Type

public enum ByteEnum : byte
{
    Zero = 0,
    One = 1,
    Two = 2,
    Three = 3
}

class Program
{
    static void Main(string[] args)
    {
        ByteEnum number = ByteEnum.Two;
        Console.WriteLine($"Value: {number}, Numeric Value: {(byte)number}");  // Output: Value: Two, Numeric Value: 2
    }
}

Output:

Value: Two, Numeric Value: 2

Explanation: The enum ByteEnum uses byte as the underlying type, which is more memory-efficient for small ranges of values. The example shows how to retrieve the numeric value of an enum member.

Key Takeaways

  • Enums provide a way to define a group of related named constants.
  • Enums start with a default underlying type of int, but this can be customized.
  • Enums can be used in switch statements, loops, and method parameters to improve code clarity.
  • Enum methods, such as Enum.Parse() and Enum.GetValues(), make it easy to work with enums programmatically.
  • Using enums helps reduce errors by limiting values to a specific set of named constants.
Prev Next