Codecademy Logo

C# Enumerations

C# Enums

An enum in C# defines a set of named constants, streamlining the use of fixed values in your code. It enhances code readability and maintainability by using meaningful names instead of arbitrary numbers. 

enum Days {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};


class Program {
    static void Main() {
        Days today = Days.Wednesday;
        Console.WriteLine($"Today is {today}.");
    }
}

Enum Switch Cases

In C#, enums are leveraged in switch statements to organize code by defining named constant values. This enhances code readability and facilitates case handling using these enumerator values.

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


Days today = Days.Wednesday;


switch (today) {
    case Days.Sunday:
        Console.WriteLine("Relax, it's Sunday!");
        break;
    case Days.Wednesday:
        Console.WriteLine("Midweek blues.");
        break;
    case Days.Friday:
        Console.WriteLine("Weekend is near!");
        break;
    default:
        Console.WriteLine("Just another day.");
        break;
}

C# Enum.GetNames()

The Enum.GetNames() method in C# is used to retrieve an array containing the names of all the constants in a specified enumeration. This is useful for iterating over enumerated types and displaying or processing them.

using System;


public enum Colors
{
    Red,
    Green,
    Blue
}


public class Program
{
    public static void Main()
    {
        string[] colorNames = Enum.GetNames(typeof(Colors));
        
        foreach (string color in colorNames)
        {
            Console.WriteLine(color);
        }
    }
}

C# Enum.GetValues()

The Enum.GetValues() method in C# extracts all constant values from a specified enumeration into an array. It’s useful to retrieve and iterate over all enum constants systematically.

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


class Program {
    static void Main() {
        Array days = Enum.GetValues(typeof(Days));


        foreach(Days day in days) {
            Console.WriteLine(day);
        }
    }
}

Enum.IsDefined() Method

The Enum.IsDefined() method in C# checks if a specified value or name is defined within a given enumeration. This is useful for verifying if values are part of an enumerated type before processing data. Use this method to enhance the stability of your applications.

using System;


public class EnumCheck
{
    enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }


    public static void Main()
    {
        int dayValue = 3;
        // Check if dayValue exists in Days enumeration
        bool doesExist = Enum.IsDefined(typeof(Days), dayValue);
        Console.WriteLine(doesExist ? "Valid day" : "Invalid day");
    }
}

C# Enum.Parse() Usage

The Enum.Parse() method in C# allows the conversion of a string to an enumerated type. This is useful for transforming user input or files into enums. Always ensure the string value matches the enumeration value to avoid exceptions.

// Assume there's an enum called Days with values: Sunday, Monday, etc.
string dayString = "Monday";
Days dayEnum = (Days) Enum.Parse(typeof(Days), dayString);
Console.WriteLine(dayEnum); // Outputs: Monday

C# Enum.TryParse()

Enum.TryParse() in C# attempts to convert a string or numeric value to an enum type. It returns true if the conversion succeeds. This is useful for validating and converting user input or external data safely without exceptions.

enum Day { Sunday, Monday, Tuesday }


string input = "Monday";
Day dayValue;
bool success = Enum.TryParse(input, out dayValue);


if (success) {
    Console.WriteLine($"Conversion succeeded: {dayValue}");
} else {
    Console.WriteLine("Conversion failed.");
}

C# Flags Enum

The Flags attribute in C# enables an enum to represent a bit field, allowing multiple options to be selected simultaneously. It’s useful for defining sets where combinations of values are valid and enumerable.

using System;


[Flags]
enum FileAccess
{
    Read = 1,
    Write = 2,
    Execute = 4,
    ReadWrite = Read | Write
}


public class Example
{
    public static void Main()
    {
        FileAccess accessRights = FileAccess.Read | FileAccess.Write;
        Console.WriteLine(accessRights);
        // Output: ReadWrite
    }
}

Defining an Enum

Enums in C# are defined using the enum keyword, followed by the name, and a pair of curly braces {} containing the enum members. Enums represent a set of named constants.

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


// Accessing enum values
Day startOfWeek = Day.Sunday;
Day endOfWeek = Day.Saturday;


// Output the values
Console.WriteLine(startOfWeek);  // Output: Sunday
Console.WriteLine(endOfWeek);    // Output: Saturday

Enum Value Assignment

Enums in C# enable you to define a set of named constants known as enumerators. You can assign specific integer values to each member or let them default to incrementing integers starting from 0. This feature enhances code readability and maintainability. 

enum Day {
   Sunday = 1,
   Monday,
   Tuesday,
   Wednesday = 10,
   Thursday,
   Friday,
   Saturday
}


// Values assigned by above:
// Sunday = 1
// Monday = 2
// Tuesday = 3
// Wednesday = 10
// Thursday = 11, and so on.

Accessing Enum Values

In C#, you can access enum values using dot notation. This enables direct utilization of enum members without the need for object instantiation, providing a static and clean way to manage constants.

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


public class Program {
    static void Main() {
        Days today = Days.Wednesday;
        Console.WriteLine($"Today is: {today}");  // Outputs: Today is: Wednesday
    }
}
Previous
Next

Learn more on Codecademy