Enum value to string

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; 
} 

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
}

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.

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.

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();
        }
    }
}