How to Compare Enum with String in C#

Comparing enums and strings in C# is a common task, and there are several ways to achieve this. This article outlines various methods, from simple built-in functions to more advanced techniques using reflection, and guides you on when to use each approach.

Using Enum.Parse

The Enum.Parse method is a straightforward way to convert a string to its corresponding enum value. It matches the input string to the name of an enum member. By default, the comparison is case-sensitive.

using System;

public enum Priority { High, Medium, Low }

public class Example
{
    public static void Main(string[] args)
    {
        var priority = (Priority)Enum.Parse(typeof(Priority), "High"); 
        Console.WriteLine(priority); // Output: High

        //Case-insensitive parsing
        var priority2 = (Priority)Enum.Parse(typeof(Priority), "medium", true);
        Console.WriteLine(priority2); // Output: Medium
    }
}

Advantages:

• Simple and easy to use.
• Built-in functionality.
• Supports case-insensitive comparison.

Disadvantages:

• Throws an ArgumentException if the string doesn’t match any enum member. Requires explicit error handling with try-catch blocks.
• Only matches based on the enum member’s name, not other attributes.

Using Enum.TryParse

Enum.TryParse offers a safer alternative to Enum.Parse. It attempts to convert the string to an enum and returns a boolean indicating success or failure. This eliminates the need for try-catch blocks.

using System;

public enum Priority { High, Medium, Low }

public class Example
{
    public static void Main(string[] args)
    {
        Priority priority;
        if (Enum.TryParse("High", out priority))
        {
            Console.WriteLine(priority); // Output: High
        }


          if (Enum.TryParse("low", true, out priority)) // Case-insensitive
        {
            Console.WriteLine(priority); // Output: Low
        }

          if (!Enum.TryParse<Priority>("Invalid", out _))
          {
             Console.WriteLine("Invalid Priority"); // Output: Invalid Priority
          }

    }
}

Advantages:

• Handles errors gracefully without exceptions.
• Simple and readable.
• Supports case-insensitive comparison.

Disadvantages:

• Still limited to matching based on the enum member’s name.

Leveraging Reflection with Custom Attributes

For more complex scenarios, reflection allows matching strings to custom attributes associated with enum members, such as a Description attribute. This provides flexibility beyond matching enum names.

using System;
using System.ComponentModel;
using System.Reflection;

public enum Status
{
    [Description("In Progress")]
    InProgress,
    [Description("Completed")]
    Complete,
    [Description("Pending Approval")]
    Pending
}

public static class EnumExtensions
{
    public static T GetValueFromDescription<T>(this string description) where T : Enum
    {
        foreach (var field in typeof(T).GetFields())
        {
            if (Attribute.GetCustomAttribute(field,
                typeof(DescriptionAttribute)) is DescriptionAttribute attribute)
            {
                if (attribute.Description == description)
                    return (T)field.GetValue(null);
            }
        }
        throw new ArgumentException("Not found.", nameof(description));
    }
}


public class Example {
     public static void Main(string[] args) {
     Console.WriteLine(Status.InProgress.ToString()); // Output: InProgress
     Console.WriteLine("Completed".GetValueFromDescription<Status>()); // Output: Complete
    }
}

Advantages:

• Highly flexible, allowing matching based on various criteria.
• Enables mapping strings to more descriptive representations of enum values.

Disadvantages:

• More complex implementation using reflection.
• Potentially slower performance compared to direct comparison methods.

Conclusion

Choosing the right method depends on your specific needs. For simple name-based matching, Enum.TryParse offers a safe and efficient solution. For scenarios requiring more flexibility and mapping to custom attributes, reflection provides the necessary tools but with potential performance trade-offs. Understanding these different techniques empowers you to effectively compare enums and strings in C#.