Converting string back to enum

Question

Is there a cleaner, more clever way to do this?

I'm hitting a DB to get data to fill an object and am converting a database string value back into its enum (we can assume that all values in the database are indeed values in the matching enum)

The line in question is the line below that sets EventLog.ActionType...the reason I began to question my method is because after the equals sign, VS2010 keeps trying to override what I'm typing by putting this: "= EventActionType("

using (..<snip>..)
{
  while (reader.Read())
  {
     // <snip>
     eventLog.ActionType = (EventActionType)Enum.Parse(typeof(EventActionType), reader[3].ToString());

...etc...

Answer 1

As far as I know, this is the best way to do it. I've set up a utility class to wrap this functionality with methods that make this look cleaner, though.

    /// <summary>
    /// Convenience method to parse a string as an enum type
    /// </summary>
    public static T ParseEnum<T>(this string enumValue)
        where T : struct, IConvertible
    {
        return EnumUtil<T>.Parse(enumValue);
    }

/// <summary>
/// Utility methods for enum values. This static type will fail to initialize 
/// (throwing a <see cref="TypeInitializationException"/>) if
/// you try to provide a value that is not an enum.
/// </summary>
/// <typeparam name="T">An enum type. </typeparam>
public static class EnumUtil<T>
    where T : struct, IConvertible // Try to get as much of a static check as we can.
{
    // The .NET framework doesn't provide a compile-checked
    // way to ensure that a type is an enum, so we have to check when the type
    // is statically invoked.
    static EnumUtil()
    {
        // Throw Exception on static initialization if the given type isn't an enum.
        Require.That(typeof (T).IsEnum, () => typeof(T).FullName + " is not an enum type.");
    }

    public static T Parse(string enumValue)
    {
        var parsedValue = (T)System.Enum.Parse(typeof (T), enumValue);
        //Require that the parsed value is defined
        Require.That(parsedValue.IsDefined(), 
            () => new ArgumentException(string.Format("{0} is not a defined value for enum type {1}", 
                enumValue, typeof(T).FullName)));
        return parsedValue;
    }

    public static bool IsDefined(T enumValue)
    {
        return System.Enum.IsDefined(typeof (T), enumValue);
    }

}

With these utility methods, you can just say:

 eventLog.ActionType = reader[3].ToString().ParseEnum<EventActionType>();

Answer 2

You can use extension methods to give some syntactic sugar to your code. You can even made this extension methods generics.

This is the kind of code I'm talking about: http://geekswithblogs.net/sdorman/archive/2007/09/25/Generic-Enum-Parsing-with-Extension-Methods.aspx

  public static T EnumParse<T>(this string value)
  {
      return EnumHelper.EnumParse<T>(value, false);
  }


  public static T EnumParse<T>(this string value, bool ignoreCase)
  {

      if (value == null)
      {
          throw new ArgumentNullException("value");
      }
      value = value.Trim();

      if (value.Length == 0)
      {

          throw new ArgumentException("Must specify valid information for parsing in the string.", "value");
      }

      Type t = typeof(T);

      if (!t.IsEnum)
      {

          throw new ArgumentException("Type provided must be an Enum.", "T");
      }

      T enumType = (T)Enum.Parse(t, value, ignoreCase);
      return enumType;
  }


  SimpleEnum enumVal = Enum.Parse<SimpleEnum>(stringValue);