Enum value to string

Question

Does anyone know how to get enum values to string?

example:

private static void PullReviews(string action, HttpContext context)
{
    switch (action)
            


        

Answer 1

You're going about this backwards. Don't try to use dynamic strings as case labels (you can't), instead parse the string into an enum value:

private static void PullReviews(string action, HttpContext context) 
{ 
    // Enum.Parse() may throw if input is invalid, consider TryParse() in .NET 4
    ProductReviewType actionType = 
        (ProductReviewType)Enum.Parse(typeof(ProductReviewType), action);

    switch (actionType) 
    { 
        case ProductReviewType.Good: 
            PullGoodReviews(context); 
            break; 
        case ProductReviewType.Bad: 
            PullBadReviews(context); 
            break; 
        default: // consider a default case for other possible values...
            throw new ArgumentException("action");
    } 
} 

EDIT: In principle, you could just compare to hard-coded strings in your switch statements (see below), but this is the least advisable approach, since it will simply break when you change the values passed in to the method, or the definition of the enum. I'm adding this since it's worth knowing that strings can be used as case labels, so long as they are compile-time literals. Dynamic values can't be used as cases, since the compiler doesn't know about them.

// DON'T DO THIS...PLEASE, FOR YOUR OWN SAKE...
switch (action) 
{ 
    case "Good": 
        PullGoodReviews(context); 
        break; 
    case "Bad": 
        PullBadReviews(context); 
        break; 
} 

Answer 2

This is just for the fun of it, but what if you used a dictionary of delegates? I realize that you have a completely different approach, but dictionary-izing might actually work better for what you're trying to accomplish, especially since it provides a high degree of modularity, as opposed to a mondo-switch construct (although I have to admit, your enum has only 2 members so its a moot issue). Anyways, I just wanted to air a different way to do things...

The dictionary-based approach would kind of look like this:

namespace ConsoleApplication1
{
    public enum ProductReviewType
    {
        Good,
        Bad
    }

    public static class StringToEnumHelper
    {
        public static ProductReviewType ToProductReviewType(this string target)
        {
            // just let the framework throw an exception if the parse doesn't work
            return (ProductReviewType)Enum.Parse(
              typeof(ProductReviewType), 
              target);
        }
    }

    class Program
    {

        delegate void ReviewHandler(HttpContext context);

        static readonly Dictionary<ProductReviewType, ReviewHandler> 
            pullReviewOperations = 
              new Dictionary<ProductReviewType, ReviewHandler>()
            {
                {ProductReviewType.Good, new ReviewHandler(PullGoodReviews)},
                {ProductReviewType.Bad, new ReviewHandler(PullBadReviews)}
            };

        private static void PullGoodReviews(HttpContext context)
        {
            // actual logic goes here...
            Console.WriteLine("Good");
        }

        private static void PullBadReviews(HttpContext context)
        {
            // actual logic goes here...
            Console.WriteLine("Bad");
        }

        private static void PullReviews(string action, HttpContext context)
        {
            pullReviewOperations[action.ToProductReviewType()](context);
        }

        static void Main(string[] args)
        {
            string s = "Good";
            pullReviewOperations[s.ToProductReviewType()](null);

            s = "Bad";
            pullReviewOperations[s.ToProductReviewType()](null);

            // pause program execution to review results...
            Console.WriteLine("Press enter to exit");
            Console.ReadLine();
        }
    }
}

Answer 3

I'd suggest you go the other way - try to use the actual enum values as much as possible (by converting the string to an enum value as soon as you can), rather than passing strings around your application:

ProductReviewType actionType = (ProductReviewType)Enum.Parse(typeof(ProductReviewType), val);
// You might want to add some error handling here.
PullReviews(actionType);

private static void PullReviews(ProductReviewType action, HttpContext context)
{
    switch (action)
    {
        case ProductReviewType.Good:
            PullGoodReviews(context);
            break;
        case ProductReviewType.Bad:
            PullBadReviews(context);
            break;
    }
}

Note that I've changed your method signature to accept a ProductReviewType argument; this makes it clear what your method actually needs to implement its logic, and fits with my original point that you should try as much as possible not to pass strings around.

Answer 4

public enum Color
{
    Red
}

var color = Color.Red;
var colorName = Enum.GetName(color.GetType(), color); // Red

Edit: Or perhaps you want..

Enum.Parse(typeof(Color), "Red", true /*ignorecase*/); // Color.Red

There is no TryParse for Enum, so if you expect errors, you have to use try/catch:

try
{
  Enum.Parse(typeof(Color), "Red", true /*ignorecase*/);
}
catch( ArgumentException )
{
  // no enum found
}

Answer 5

Yes, you can use .ToString() to get a string value for an enum, however you can't use .ToString() in a switch statement. Switch statements need constant expressions, and .ToString() does not evaluate until runtime, so the compiler will throw an error.

To get the behavior you want, with a little change in the approach, you can use enum.Parse() to convert the action string to an enum value, and switch on that enum value instead. As of .NET 4 you can use Enum.TryParse() and do the error checking and handling upfront, rather than in the switch body.

If it were me, I'd parse the string to an enum value and switch on that, rather than switching on the string.

private static void PullReviews(string action, HttpContext context)
{
    ProductReviewType review;

    //there is an optional boolean flag to specify ignore case
    if(!Enum.TryParse(action,out review))
    {
       //throw bad enum parse
    }


    switch (review)
    {
        case ProductReviewType.Good:
            PullGoodReviews(context);
            break;
        case ProductReviewType.Bad:
            PullBadReviews(context);
            break;
        default:
            //throw unhandled enum type
    }
}

Answer 6

This code is gonna works.

private enum ProductReviewType{good, bad};

private static void PullReviews(string action)
{
    string goodAction = Enum.GetName(typeof(ProductReviewType), ProductReviewType.good);
    string badAction = Enum.GetName(typeof(ProductReviewType), ProductReviewType.bad);
    if (action == goodAction)
    {
        PullGoodReviews();
    }
    else if (action == badAction)
    {
        PullBadReviews();
    }
}

public static void PullGoodReviews()
{
    Console.WriteLine("GOOD Review!");
}

public static void PullBadReviews()
{
    Console.WriteLine("BAD Review...");
}

Since the parsed string is not constant it can not be used by Switch statement. Compiled in VS2005

You can use another temp variable to save the Type of enum class, this may improve performance.