C# Enum return string with breaks

Question

I need my enum to return a specific string, but I can't work out how to make it return a string with breaks in it without having a method to do the conversion. Is it possible to make LicenseTypes.DISCOUNT_EARLY_ADOPTER return DISCOUNT EARLY-ADOPTER without the helper method?

// All license types
public enum LicenseTypes
{
    DISCOUNT,
    DISCOUNT_EARLY_ADOPTER,
    COMMERCIAL,
    COMMERCIAL_EARLY_ADOPTER
}

// Convert enum to correct string
public static string LicenseTypeToString(LicenseTypes Enum)
{
    if (Enum == LicenseTypes.COMMERCIAL)
        return "COMMERCIAL";
    else if (Enum == LicenseTypes.COMMERCIAL_EARLY_ADOPTER)
        return "COMMERCIAL EARLY-ADOPTER";
    else if (Enum == LicenseTypes.DISCOUNT)
        return "DISCOUNT";
    else if (Enum == LicenseTypes.DISCOUNT_EARLY_ADOPTER)
        return "DISCOUNT EARLY-ADOPTER";
    else
        return "ERROR";
}

@Bolt, I mean it returns the string "DISCOUNT EARLY-ADOPTER" which has the space gap in it, the enum doesn't like spaces so I have to underscore them — Tom Gullen, Aug 05 '11 at 22:11
Have you seen this [post](http://stackoverflow.com/questions/1117542/spaces-in-c-enums) that talks about using System.ComponentModel.DescriptionAttribute to create better enum descriptions with spaces? — Zachary, Aug 05 '11 at 22:16
As much as you might hate it, I actually don't think there's really anything particularly wrong with your simple helper method approach. I'd only suggest using a `switch` statement instead of a bunch of `if`/`else` blocks, as the compiler can do a better job optimizing it. — Dan Tao, Aug 05 '11 at 22:17

Jon Skeet · Accepted Answer · 2011-08-05T22:19:04.690

Firstly, a separate option from a helper method is simply to have a Dictionary<LicenseTypes, string> which you populate once. That would probably be the simplest approach, to be honest:

private static readonly Dictionary<LicenseTypes, string> LicenseDesciptions =
    new Dictionary<LicenseTypes, string> 
{
    { LicenseTypes.COMMERCIAL, "COMMERCIAL" },
    { LicenseTypes.COMMERCIAL_EARLY_ADOPTER, "COMMERCIAL EARLY-ADOPTER" },
    { LicenseTypes.DOMESTIC, "DOMESTIC" },
    { LicenseTypes.DOMESTIC_EARLY_ADOPTER, "DOMESTIC EARLY-ADOPTER" },
};

(As noted in comments, another alternative is a switch/case... but I personally prefer this way, as effectively you've got a data mapping, so it makes sense to use a data structure rather than an execution flow structure. It also means you can swap out dictionaries for different languages etc if you want.)

Secondly, one option would be to decorate each enum value with a [Description] attribute (or your own attribute if you want), and find that out with reflection - Unconstrained Melody has an extension method which can do that very easily:

// Throws ArgumentOutOfRangeException if the licenseType value isn't defined
// or doesn't have a description.
string description = licenseType.GetDescription();

Also, following .NET naming conventions it should be:

public enum LicenseType // Singular as it's not a Flags enum
{
    Discount,
    DiscountEarlyAdopter,
    Commercial,
    CommercialEarlyAdopter
}

Thanks Jon! Great answer, also I bought your book the other week and am going to start getting in to it, seems brilliant! — Tom Gullen, Aug 05 '11 at 22:22
+1: I like your argument for using a data structure for a data mapping. — Dan Tao, Aug 05 '11 at 22:22
@Tom: Cool - hope you enjoy the book. Ping me if anything doesn't make sense :) — Jon Skeet, Aug 05 '11 at 22:23

score 2 · Answer 2 · edited May 23 '17 at 12:11

A little reflection, and Attribute magic, and this should just answer it :)
Getting attributes of Enum's value

Might also make it an extension method.

here's how it should look (also added generics):

public static class MyExtensionsClass
{
    public static string ToDescriptionString<T>(this T val)
        where T : struct, IConvertible
    {
        if (typeof(T).IsEnum) 
        {
           var type = val.GetType();
           var memInfo = type.GetMember(val.ToString());
           var attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
           return ((DescriptionAttribute)attributes[0]).Description;
        }
        return ""; //all paths must return a value
    }
}

public enum LicenseTypes
{
    [Description("DISCOUNT")]
    DISCOUNT,
    [Description("DISCOUNT EARLY-ADOPTER")]
    DISCOUNT_EARLY_ADOPTER,
    [Description("COMMERCIAL")]
    COMMERCIAL,
    [Description("COMMERCIAL EARLY-ADOPTER")]
    COMMERCIAL_EARLY_ADOPTER
}

Thank you, guys that wrote these:

Good luck!

score 1 · Answer 3 · answered Aug 05 '11 at 22:21

While it doesn't eliminate the helper method, note that in your case you could just special-case the values that you can't get using ToString:

switch (Enum) {
    case LicenseTypes.COMMERCIAL_EARLY_ADOPTER:
        return "COMMERCIAL EARLY-ADOPTER";
    case LicenseTypes.DISCOUNT_EARLY_ADOPTER:
        return "DISCOUNT EARLY-ADOPTER";
    default
        return Enum.ToString();
}

Skomski · Answer 4 · 2011-08-05T22:39:07.503

1

I use this from Google's dotnet client - StringValueAttribute.cs and Utilities.cs

public enum LicenseType
{
     [StringValue("DISCOUNT")] Discount,
     [StringValue("DISCOUNT EARLY-ADOPTER")] DiscountEarlyAdopter,
     [StringValue("COMMERCIAL")] Commercial,
     [StringValue("COMMERCIAL EARLY-ADOPTER")] CommercialEarlyAdopter
}

Then you can simply do this:

licenseType.GetStringValue();

edited Aug 05 '11 at 22:39

answered Aug 05 '11 at 22:27

Skomski

4,827
21
30

score 0 · Answer 5 · answered Aug 05 '11 at 22:22

0

Convert to string using "G" format, then replace "_" (underscore) with spaces:

LicensceTypes license = LicenseTypes.COMMERCIAL_EARLY_ADOPTERS;
string licenseDescription = license.ToString("G").Replace('_', ' ');
// licenseDescription = "COMMERCIAL EARLY ADOPTERS"

answered Aug 05 '11 at 22:22

SalvadorGomez

552
4
15

Thanks for the answer but that's hard to maintain if we add other licenses in the future which have underscores etc! – Tom Gullen Aug 05 '11 at 22:23
This leaves out the OP's desired hyphen (`-`), though. – Dan Tao Aug 05 '11 at 22:23

score 0 · Answer 6 · answered Aug 05 '11 at 22:24

I think I would use a class to avoid this scenario. :/

public class LicenceType
{
    private string name;
    public LicenceType(string Name)
    {
        this.name = Name;
    }
    public override string ToString()
    {
        return name;
    }
}

public static class LicenceTypes
{
    public static LicenceType DISCOUNT = new LicenceType("DISCOUNT");
    public static LicenceType DISCOUNT_EARLY_ADOPTER= new LicenceType("DISCOUNT EARLY-ADOPTER");
    public static LicenceType COMMERCIAL= new LicenceType("COMMERCIAL");
    public static LicenceType COMMERCIAL_EARLY_ADOPTER= new LicenceType("COMMERCIAL EARLY-ADOPTER");
}

C# Enum return string with breaks

6 Answers6