An attribute class for providing description for enum types in C# and util methods to retrieve description written for enum types(if that attribute is used0.)

EnumDescription.cs

/// <summary>
/// Provides a description for an enumerated type.
/// </summary>
[AttributeUsage(AttributeTargets.Enum | AttributeTargets.Field,
 AllowMultiple = false)]
public sealed class EnumDescriptionAttribute : Attribute
{
    private string description;


    /// <summary>
    /// Gets the description stored in this attribute.
    /// </summary>
    /// <value>The description stored in the attribute.</value>
    public string Description
    {
        get
        {
            return this.description;
        }
    }


    /// <summary>
    /// Initializes a new instance of the
    /// <see cref="EnumDescriptionAttribute"/> class.
    /// </summary>
    /// <param name="description">The description to store in this attribute.
    /// </param>
    public EnumDescriptionAttribute(string description)
        : base()
    {
        this.description = description;
    }
}


/// <summary>
/// Provides a static utility object of methods and properties to interact
/// with enumerated types.
/// </summary>
public static class EnumUtilities
{
    /// <summary>
    /// Gets the <see cref="DescriptionAttribute" /> of an <see cref="Enum" /> 
    /// type value.
    /// </summary>
    /// <param name="value">The <see cref="Enum" /> type value.</param>
    /// <returns>A string containing the text of the
    /// <see cref="DescriptionAttribute"/>.</returns>
    public static string GetDescription(this Enum value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("value");
        }

        string description = value.ToString();
        FieldInfo fieldInfo = value.GetType().GetField(description);
        EnumDescriptionAttribute[] attributes =
           (EnumDescriptionAttribute[])
         fieldInfo.GetCustomAttributes(typeof(EnumDescriptionAttribute), false);

        if (attributes != null && attributes.Length > 0)
        {
            description = attributes[0].Description;
        }
        return description;
    }
    /// <summary>
    /// Parses the supplied enum and string value to find an associated enum value (case sensitive).
    /// </summary>
    /// <param name="type">Type.</param>
    /// <param name="stringValue">String value.</param>
    /// <returns>Enum value associated with the string value, or null if not found.</returns>
    public static object Parse(Type type, string stringValue)
    {
        return Parse(type, stringValue, false);
    }

    /// <summary>
    /// Parses the supplied enum and string value to find an associated enum value.
    /// </summary>
    /// <param name="type">Type.</param>
    /// <param name="stringValue">String value.</param>
    /// <param name="ignoreCase">Denotes whether to conduct a case-insensitive match on the supplied string value</param>
    /// <returns>Enum value associated with the string value, or null if not found.</returns>
    public static object Parse(Type type, string stringValue, bool ignoreCase)
    {
        object output = null;
        string enumStringValue = null;

        if (!type.IsEnum)
        {
            throw new ArgumentException(String.Format("Supplied type must be an Enum.  Type was {0}", type.ToString()));
        }
            
        //Look for our string value associated with fields in this enum
        foreach (FieldInfo fi in type.GetFields())
        {
            //Check for our custom attribute
            EnumDescriptionAttribute[] attrs = fi.GetCustomAttributes(typeof(EnumDescriptionAttribute), false) as EnumDescriptionAttribute[];
            if (attrs.Length > 0)
            {
                enumStringValue = attrs[0].Description;
            }

            //Check for equality then select actual enum value.
            if (string.Compare(enumStringValue, stringValue, ignoreCase) == 0)
            {
                output = Enum.Parse(type, fi.Name);
                break;
            }
        }

        return output;
    }

    
    /// <summary>
    /// Return the existence of the given string value within the enum.
    /// </summary>
    /// <param name="stringValue">String value.</param>
    /// <param name="enumType">Type of enum</param>
    /// <returns>Existence of the string value</returns>
    public static bool IsStringDefined(Type enumType, string stringValue)
    {
        return Parse(enumType, stringValue) != null;
    }


    /// <summary>
    /// Return the existence of the given string value within the enum.
    /// </summary>
    /// <param name="stringValue">String value.</param>
    /// <param name="enumType">Type of enum</param>
    /// <param name="ignoreCase">Denotes whether to conduct a case-insensitive match on the supplied string value</param>
    /// <returns>Existence of the string value</returns>
    public static bool IsStringDefined(Type enumType, string stringValue, bool ignoreCase)
    {
        return Parse(enumType, stringValue, ignoreCase) != null;
    }


    /// <summary>
    /// Converts the <see cref="Enum" /> type to an <see cref="IList" /> 
    /// compatible object.
    /// </summary>
    /// <param name="type">The <see cref="Enum"/> type.</param>
    /// <returns>An <see cref="IList"/> containing the enumerated
    /// type value and description.</returns>
    public static IList<KeyValuePair<Enum, string>> ToList(this Type type)
    {
        if (type == null)
        {
            throw new ArgumentNullException("type");
        }

        List<KeyValuePair<Enum, string>> list = new List<KeyValuePair<Enum, string>>();
        Array enumValues = Enum.GetValues(type);

        foreach (Enum value in enumValues)
        {
            list.Add(new KeyValuePair<Enum, string>(value, GetDescription(value)));
        }

        return list;
    }
}