How to assign string values to enums and use that value in a switch

I wanted to add another answer for anyone using C# 6 or greater.

If you are only wanting to get the name of the Enum value, you could use the new nameof() method introduced in C# 6.

string enumName = nameof(MyEnum.EnumVal1); // enumName will equal "EnumVal1"

While this may seem like overkill at first glance (why not just set the value of the string to "EnumVal1" to start with?), it will give you compile-time checking to make sure the value is valid. So, if you ever change the name of the enum value and forget to tell your IDE to find and replace all references, it will not compile until you fix them.

You can't have an enum with an underlying type of string. The underlying type can be any integral type except char.

If you want to translate a string to your enum then you'll probably need to use the Parse or TryParse methods.

string incoming = "doctor";

// throws an exception if the string can't be parsed as a TestEnum
TestEnum foo = (TestEnum)Enum.Parse(typeof(TestEnum), incoming, true);

// try to parse the string as a TestEnum without throwing an exception
TestEnum bar;
if (Enum.TryParse(incoming, true, out bar))
{
    // success
}
else
{
    // the string isn't an element of TestEnum
}

// ...

enum TestEnum
{
    Doctor, Mr, Mrs
}

I found that the best way for me to do this is by using the System.ComponentModel.DescriptionAttribute attribute on the enum values.

Here is an example:

using System.ComponentModel;

public enum ActionCode
{
    [Description("E")]
    Edit,
    [Description("D")]
    Delete,
    [Description("R")]
    Restore
}

Then, to use it, create an extension method on a static class like so:

Edit: I rewrote the method to include a great suggestion from Laurie Dickinson so that the method returns the name of the enum value when there is no Description attribute. I also refactored the method to try to improve functionality. It now works for all Enums without using IConvertible.

public static class Extensions
{
    public static string GetDescription(this Enum e)
    {
        var attribute =
            e.GetType()
                .GetTypeInfo()
                .GetMember(e.ToString())
                .FirstOrDefault(member => member.MemberType == MemberTypes.Field)
                .GetCustomAttributes(typeof(DescriptionAttribute), false)
                .SingleOrDefault()
                as DescriptionAttribute;

        return attribute?.Description ?? e.ToString();
    }
}

So, to get the string associated with our enum above, we could use the following code:

using Your.Extension.Method.Namespace;

...

var action = ActionCode.Edit;
var actionDescription = action.GetDescription();

// Value of actionDescription will be "E".

Here is another sample Enum:

public enum TestEnum
{
    [Description("This is test 1")]
    Test1,
    Test2,
    [Description("This is test 3")]
    Test3

}

Here is the code to see the description:

var test = TestEnum.Test2;
var testDescription = test.GetDescription();
test = TestEnum.Test3;
var testDescription2 = test.GetDescription();

Results will be:

testDescription: "Test2"
testDescription2: "This is test 3"

I wanted to go ahead and post the generic method as it is much more useful. It prevents you from having to write a custom extension for all of your enums.

I believe the standard way to do this is to use a static class with readonly string properties that return the value you want.