`Enum.Parse`

This C# method converts strings to enum values. It is useful in programs that accept user input as a string, but store the value internally as an enum.

An enum is a more efficient representation than a string. When we have a choice, an enum is better. Enum.TryParse too is covered.

Example

The Enum.Parse method is a static method in the System namespace, so you will need to include System at the top of your file or use the fully qualified name.

Detail Here we see an enum type "PetType" containing a constant "Dog" with value of 2.

Part 1 We call Enum.Parse. The "typeof PetType" returns the enum type. We cast the result of Enum.Parse to the PetType enum type.

Part 2 At the end, we test the result of the Enum.Parse method. We print a short message if the test succeeds.

using System;

class Program
{
    enum PetType
    {
        None,
        Cat = 1,
        Dog = 2
    }

    static void Main()
    {
        string value = "Dog";

        // Part 1: try to convert the string to an enum.
        PetType pet = (PetType)Enum.Parse(typeof(PetType), value);

        // Part 2: see if the conversion succeeded.
        if (pet == PetType.Dog)
        {
            Console.WriteLine("Equals dog.");
        }
    }
}
Equals dog.

Generic method

A generic method receives a type parameter, and with the Enum.Parse generic method, we can avoid casting the result. This is a better method to call—it is safer.

using System;

class Program
{
    enum PetType
    {
        None, Cat, Dog
    }

    static void Main()
    {
        string value = "Cat";
        // Use generic Parse method.
        PetType pet = Enum.Parse<PetType>(value);
        Console.WriteLine(pet);
    }
}
Cat

Exceptions

An exception may be raised when parsing enums. When the contents of the string you try to parse is not represented in the enum, you must handle the exception.

Detail Please look at the try-catch block. The code catches all errors, which is sufficient for many small applications.

Result The string in the example isn't found in the enum PetType, so the enum variable is set to PetType.None.

using System;

class Program
{
    enum PetType
    {
        None,
        Cat = 1,
        Dog = 2
    }

    static void Main()
    {
        // The enum doesn't contain this value.
        string value = "Bat";

        // Try to convert the string to an enum.
        PetType pet;
        try
        {
            pet = (PetType)Enum.Parse(typeof(PetType), value);
        }
        catch (Exception ex)
        {
            // The conversion failed.
            Console.WriteLine("FAILED");
            Console.WriteLine(ex.Message);

            // Set fallback value.
            pet = PetType.None;
        }

        // See if the conversion succeeded.
        if (pet == PetType.Dog)
        {
        }
    }
}FAILED
Requested value 'Bat' was not found.

`Enum.TryParse`

Please notice the names of the enumerated constants. Before calling Enum.TryParse, you can declare a variable of the enum type. You do not need to initialize it.

Then Test the result of Enum.TryParse for true or false. If the method returns true, then the string was successfully parsed.

using System;

enum Importance
{
    None,
    Low,
    Medium,
    Critical
}

class Program
{
    static void Main()
    {
        // The input value.
        string value = "Medium";

        // An uninitialized variable.
        Importance importance;

        // Call Enum.TryParse method.
        if (Enum.TryParse(value, out importance))
        {
            // We now have an enum type.
            Console.WriteLine(importance == Importance.Medium);
        }
    }
}
True

Number quirk

Enum.TryParse will parse a string representation of a number as an enum value. This behavior might not be expected. Consider using the Enum.IsDefined method to test.

Tip Whenever you have a string that you want to convert into an enum, consider using the Enum.TryParse static method.

using System;

enum Importance
{
    None = 0,
    Low = 1
}

class Program
{
    static void Main()
    {
        Importance importance;

        // ... Try to parse the string "1".
        if (Enum.TryParse("1", out importance))
        {
            // ... "1" is treated as "Low".
            Console.WriteLine(importance);
        }
    }
}
Low

`Enum.IsDefined`

Please consider calling Enum.TryParse before calling IsDefined. If TryParse returns true, and IsDefined succeeds, you have a correct string value.

using System;

enum Importance
{
    None = 0,
    Low = 1
}

class Program
{
    static void Main()
    {
        // ... "1" is not defined.
        // ... "Low" is defined.
        Console.WriteLine(Enum.IsDefined(typeof(Importance), "1"));
        Console.WriteLine(Enum.IsDefined(typeof(Importance), "Low"));
    }
}False
True

Enum.Parse receives the type of operator result and the string input. We saw a successful call to Enum.Parse—and one that failed and threw an exception.