Converting string back to enum

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

Could use an extension method like so:

public static EventActionType ToEventActionType(this Blah @this) { return (EventActionType)Enum.Parse(typeof(EventActionType), @this.ToString()); } 

And use it like:

eventLog.ActionType = reader[3].ToEventActionType(); 

Where Blah above is the type of reader[3].

You could get any enum value back, not just EventActionType as in your case with the followin method.

public static T GetEnumFromName<T>(this object @enum) { return (T)Enum.Parse(typeof(T), @enum.ToString()); } 

You can call it then,

eventLog.ActionType = reader[3].GetEnumFromName<EventActionType>() 

This is a more generic approach.

@StriplingWarrior's answer didn't work at first try, so I made some modifications:

Helpers/EnumParser.cs

namespace MyProject.Helpers { /// <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 EnumParser<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 EnumParser() { // Throw Exception on static initialization if the given type isn't an enum. if (!typeof (T).IsEnum) throw new Exception(typeof(T).FullName + " is not an enum type."); } public static T Parse(string enumValue) { var parsedValue = (T)Enum.Parse(typeof (T), enumValue); //Require that the parsed value is defined if (!IsDefined(parsedValue)) throw 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 Enum.IsDefined(typeof (T), enumValue); } } } 

Extensions/ParseEnumExtension.cs

namespace MyProject.Extensions { public static class ParseEnumExtension { /// <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 EnumParser<T>.Parse(enumValue); } } }