How to Convert a String to an Enum in C#

By the end of this page, you will understand how to convert strings into enum values in C#, when to use Enum.Parse versus Enum.TryParse, how to safely handle invalid input, and how this commonly appears in web forms, APIs, and application code.

In C#, an enum is a type that represents a fixed set of named constants. Enums make code easier to read because you can use meaningful names like Active, Pending, or Archived instead of raw numbers.

When data comes from outside your program—such as an HTML form, query string, JSON payload, configuration file, or database—it often arrives as a string. If that string is meant to represent an enum member, you need to convert it into the actual enum type before using it safely in your code.

C# provides built-in tools for this:

• Enum.Parse(...) converts a string to an enum value, but throws an exception if the string is invalid.
• Enum.TryParse(...) attempts the conversion and returns true or false instead of throwing an exception.

This matters in real programs because user input is not always reliable. Safe enum parsing helps prevent crashes and makes validation clearer.

For most modern C# code, Enum.TryParse<TEnum>(...) is the preferred approach because it is safer and easier to use with external input.

Think of an enum like a menu with a fixed list of valid choices:

• Active
• Inactive
• Deleted

A string is just text someone typed or selected, like a note that says "Active".

Parsing is the process of checking whether that note matches one of the official menu options and, if it does, turning it into the real enum value your program understands.

So:

• A string is a label written on paper.
• An enum value is the official item in your system.
• Parsing is the act of matching the label to the official item.

If the label is wrong, your program either:

• throws an error with Enum.Parse, or
• safely reports failure with Enum.TryParse.

Basic enum definition

public enum CopyStatusEnum
{
    Active,
    Inactive,
    Deleted
}

Using Enum.Parse

string input = "Active";
CopyStatusEnum status = (CopyStatusEnum)Enum.Parse(typeof(CopyStatusEnum), input);

This works, but it throws an exception if input does not match a valid enum member.

Using Enum.TryParse (recommended)

string input = "Active";

if (Enum.TryParse<CopyStatusEnum>(input, out var status))
{
    Console.WriteLine(status); // Active
}
else
{
    Console.WriteLine("Invalid status value.");
}

This is safer because it does not throw an exception for invalid input.

Ignoring letter case

string input = "active";

if (Enum.TryParse<CopyStatusEnum>(input, ignoreCase: true,   status))
{
    Console.WriteLine(status); 
}

Consider this example:

public enum CopyStatusEnum
{
    Active,
    Inactive,
    Deleted
}

string input = "Inactive";

if (Enum.TryParse<CopyStatusEnum>(input, out var status))
{
    Console.WriteLine($"Parsed: {status}");
}
else
{
    Console.WriteLine("Invalid value");
}

Step-by-step

1. The enum CopyStatusEnum is defined with three valid values:

   • Active
   • Inactive
   • Deleted

2. The variable input contains the string "Inactive".

3. Enum.TryParse<CopyStatusEnum>(input, out var status) checks whether "Inactive" matches one of the enum member names.

4. Because Inactive exists in the enum, parsing succeeds.

5. The method returns .

Enums parsed from strings appear in many common scenarios:

Web forms

A <select> field may submit values like "Active" or "Deleted", which need to be converted into an enum before saving or processing.

APIs

A request body or query parameter might include status text:

{
  "status": "Active"
}

Your C# code may need to convert that string to an enum for validation and business rules.

Configuration files

Application settings often store modes as strings such as "Development", "Production", or "Testing".

Command-line tools

A CLI app may accept arguments like:

myapp --mode Active

That mode string is often parsed into an enum.

Database or CSV imports

Imported text values may need to be converted to enums before they can be used consistently in the system.

In real projects, developers usually avoid direct Enum.Parse on untrusted input and instead use safer patterns.

Pattern: validation with TryParse

if (!Enum.TryParse<CopyStatusEnum>(input, true, out var status))
{
    return "Invalid status provided.";
}

This is common in controllers, services, and import routines.

Pattern: guard clause

if (string.IsNullOrWhiteSpace(input))
{
    throw new ArgumentException("Status is required.");
}

if (!Enum.TryParse<CopyStatusEnum>(input, true, out var status))
{
    throw new ArgumentException("Invalid status.");
}

Guard clauses reject bad input early.

Pattern: combine parsing with Enum.IsDefined

Sometimes developers want to reject numeric values or undefined values explicitly:

if (Enum.TryParse<CopyStatusEnum>(input, ,   status) &&
    Enum.IsDefined((CopyStatusEnum), status))
{
    Console.WriteLine();
}

{
    Console.WriteLine();
}

1. Forgetting to cast when using Enum.Parse

Broken code:

CopyStatusEnum status = Enum.Parse(typeof(CopyStatusEnum), "Active");

Why it fails:

• Enum.Parse returns object, so you must cast it.

Correct version:

CopyStatusEnum status = (CopyStatusEnum)Enum.Parse(typeof(CopyStatusEnum), "Active");

2. Using Enum.Parse on unsafe user input

Broken idea:

var status = (CopyStatusEnum)Enum.Parse(typeof(CopyStatusEnum), userInput);

Why it is risky:

• Invalid input throws an exception.

Safer version:

if (Enum.TryParse<CopyStatusEnum>(userInput, out var status))
{
    // safe to use
}

3. Not handling case differences

Enum.Parse vs Enum.TryParse

// Parse
var status1 = (CopyStatusEnum)Enum.Parse((CopyStatusEnum), );


 (Enum.TryParse<CopyStatusEnum>(,   status2))
{
    Console.WriteLine(status2);
}

Quick syntax

// Safe parsing
if (Enum.TryParse<MyEnum>(input, out var value))
{
    // use value
}

// Safe parsing, ignore case
if (Enum.TryParse<MyEnum>(input, true, out var value))
{
    // use value
}

// Parse with exception on failure
MyEnum value = (MyEnum)Enum.Parse(typeof(MyEnum), input);

Rules to remember

• Enum.Parse returns object, so cast it.
• Enum.TryParse is safer for user input.
• Use ignoreCase: true if input might differ in capitalization.
• TryParse may accept numeric strings like "1".
• Use Enum.IsDefined(...) if you want to ensure the result is a named enum value.

Common safe pattern

if (!string.IsNullOrWhiteSpace(input) &&
    Enum.TryParse<CopyStatusEnum>(input, ,   status) &&
    Enum.IsDefined((CopyStatusEnum), status))
{
    
}

How do I convert a string to an enum in C#?

Use Enum.TryParse<TEnum>(input, out var value) for safe parsing, or Enum.Parse(typeof(TEnum), input) if you want an exception on invalid input.

Should I use Enum.Parse or Enum.TryParse?

Use Enum.TryParse for most real-world input because it safely handles invalid values without throwing exceptions.

Can Enum.TryParse ignore uppercase and lowercase differences?

Yes. Use the overload with ignoreCase: true.

Enum.TryParse<MyEnum>(input, true, out var value)

Why does Enum.Parse need a cast?

Because Enum.Parse returns object, not the specific enum type.

Can I parse numeric strings like "1" into an enum?

Yes, in many cases C# allows that. If you only want named values like "Active", also check with .

• Enums in C# — The base concept needed to understand what values can be parsed.
• Type casting in C# — Important because Enum.Parse returns object.
• Exception handling in C# — Useful when working with Enum.Parse and possible failures.
• Input validation — Closely related because enum parsing often deals with user-provided data.
• ASP.NET model binding — Relevant when enum values come from forms or HTTP requests.
• String handling in C# — Helpful for trimming, normalizing, and validating input before parsing.
• Guard clauses — Common pattern for rejecting invalid enum input early.