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

To convert a string to an enum in C#, use the built-in methods Enum.Parse or Enum.TryParse. Here’s a detailed guide with examples:

1. Basic Conversion with Enum.Parse

Parses a string into an enum value. Throws exceptions for invalid input.
Syntax:

YourEnumType result = (YourEnumType)Enum.Parse(typeof(YourEnumType), "YourString");

Example:

using System;

public enum Color { Red, Green, Blue }

public class Program
{
    public static void Main()
    {
        string input = "Green";
        Color color = (Color)Enum.Parse(typeof(Color), input);
        Console.WriteLine(color); // Output: Green
    }
}

Error Handling:

• Throws ArgumentException if the string is invalid.
• Throws ArgumentNullException if the string is null.

2. Safer Conversion with Enum.TryParse

Avoids exceptions by returning a bool for success/failure.
Syntax:

bool success = Enum.TryParse("YourString", out YourEnumType result);

Example:

using System;

public enum Day { Monday, Tuesday, Wednesday }

public class Program
{
    public static void Main()
    {
        string input = "InvalidDay";
        if (Enum.TryParse(input, out Day day))
        {
            Console.WriteLine(day);
        }
        else
        {
            Console.WriteLine("Invalid input"); // Output: Invalid input
        }
    }
}

3. Case-Insensitive Parsing

Use the ignoreCase parameter to handle case mismatches.
Example:

// Case-insensitive parsing with Enum.Parse
Color color = (Color)Enum.Parse(typeof(Color), "green", ignoreCase: true);

// Case-insensitive parsing with Enum.TryParse
Enum.TryParse("GREEN", ignoreCase: true, out Color color);

4. Handling Numeric Strings

Parse strings representing enum values as integers.
Example:

public enum Status { Pending = 0, Active = 1, Archived = 2 }

string input = "1";
Status status = (Status)Enum.Parse(typeof(Status), input); // Returns Status.Active

---

5. Flags Enums (Comma-Separated Values)

Parse combined flags using comma-separated strings (for enums with [Flags]).
Example:

[Flags]
public enum Permissions { Read = 1, Write = 2, Execute = 4 }

string input = "Read, Write";
Permissions perms = (Permissions)Enum.Parse(typeof(Permissions), input);
Console.WriteLine(perms); // Output: Read, Write

Key Differences

Method	Enum.Parse	Enum.TryParse
Exception	Throws on invalid input	Returns false for invalid input
Performance	Slower (due to exceptions)	Faster (no exceptions)
Use Case	When input is trusted	When input is untrusted

Best Practices

1. Use TryParse for user input to avoid exceptions.
2. Validate results for critical workflows.
3. Combine with Enum.IsDefined to check validity after parsing:

   if (Enum.TryParse(input, out Color color) && Enum.IsDefined(typeof(Color), color))
   {
       // Valid enum value
   }

Common Errors

1. Invalid string:

   // Throws ArgumentException
   var invalid = (Color)Enum.Parse(typeof(Color), "Yellow");

2. Null input:

   // Throws ArgumentNullException
   var invalid = (Color)Enum.Parse(typeof(Color), null);

Full Example

using System;

public enum LogLevel { Info, Warning, Error }

public class Program
{
    public static void Main()
    {
        string userInput = "Warning";

        // Safely parse input
        if (Enum.TryParse(userInput, ignoreCase: true, out LogLevel level))
        {
            Console.WriteLine($"Log level: {level}"); // Output: Log level: Warning
        }
        else
        {
            Console.WriteLine("Invalid log level");
        }
    }
}

This covers all scenarios for converting strings to enums in C#!