Enum Helper

  public static class EnumHelper
    {
        #region get

        /// <summary>
        ///  获得枚举类型所包含的全部项的列表
        /// </summary>
        /// <param name="enumType">枚举的类型</param>
        /// <returns></returns>
        public static List<EnumItem> GetEnumItems(Type enumType)
        {
            return GetEnumItems(enumType, false);
        }

        /// <summary>
        /// 获得枚举类型所包含的全部项的列表，包含"All"。
        /// </summary>
        /// <param name="enumType">枚举对象类型</param>
        /// <returns></returns>
        public static List<EnumItem> GetEnumItemsWithAll(Type enumType)
        {
            return GetEnumItems(enumType, true);
        }

        /// <summary>
        /// 获得枚举类型所包含的全部项的列表
        /// </summary>
        /// <param name="enumType">枚举对象类型</param>
        /// <param name="withAll">是否需要包含'All'</param>
        /// <returns></returns>
        public static List<EnumItem> GetEnumItems(Type enumType, bool withAll)
        {
            List<EnumItem> list = new List<EnumItem>();

            if (enumType.IsEnum != true)
            {
                //whether the type is enum type
                throw new InvalidOperationException();
            }

            if (withAll == true)
                list.Add(new EnumItem(-, "All"));

            // 获得特性Description的类型信息
            Type typeDescription = typeof(DescriptionAttribute);

            // 获得枚举的字段信息（因为枚举的值实际上是一个static的字段的值）
            System.Reflection.FieldInfo[] fields = enumType.GetFields();

            // 检索所有字段
            foreach (FieldInfo field in fields)
            {
                // 过滤掉一个不是枚举值的，记录的是枚举的源类型
                if (field.FieldType.IsEnum == false)
                    continue;

                // 通过字段的名字得到枚举的值
                int value = (int)enumType.InvokeMember(field.Name, BindingFlags.GetField, null, null, null);
                string text = string.Empty;

                // 获得这个字段的所有自定义特性，这里只查找Description特性
                object[] arr = field.GetCustomAttributes(typeDescription, true);
                if (arr.Length > )
                {
                    // 因为Description自定义特性不允许重复，所以只取第一个
                    DescriptionAttribute aa = (DescriptionAttribute)arr[];

                    // 获得特性的描述值
                    text = aa.Description;
                }
                else
                {
                    // 如果没有特性描述，那么就显示英文的字段名
                    text = field.Name;
                }
                list.Add(new EnumItem(value, text));
            }

            return list;
        }

        /// <summary>
        /// the the enum value's descrption attribute information
        /// </summary>
        /// <param name="enumType">the type of the enum</param>
        /// <param name="value">the enum value</param>
        /// <returns></returns>
        public static string GetDescriptionByEnum<T>(T t)
        {
            if (t == null)
            {
                return null;
            }
            Type enumType = typeof(T);
            List<EnumItem> list = GetEnumItems(enumType);
            foreach (EnumItem item in list)
            {
                if (Convert.ToInt32(item.Key) == Convert.ToInt32(t))
                    return item.Value.ToString();
            }
            return string.Empty;
        }

        public static string GetDescriptionByEnum(object t)
        {
            if (t == null)
            {
                return string.Empty;
            }
            Type enumType = t.GetType();
            List<EnumItem> list = GetEnumItems(enumType);
            foreach (EnumItem item in list)
            {
                if (Convert.ToInt32(item.Key) == Convert.ToInt32(t))
                    return item.Value.ToString();
            }
            return string.Empty;
        }

        /// <summary>
        /// get the enum value's int mode value
        /// </summary>
        /// <param name="enumType">the type of the enum</param>
        /// <param name="value">the enum value's descrption</param>
        /// <returns></returns>
        public static int GetValueByDescription<T>(string description)
        {
            Type enumType = typeof(T);
            List<EnumItem> list = GetEnumItems(enumType);
            foreach (EnumItem item in list)
            {
                if (item.Value.ToString().ToLower() == description.Trim().ToLower())
                    return Convert.ToInt32(item.Key);
            }
            return -;
        }

        /// <summary>
        /// get the Enum value according to the its decription
        /// </summary>
        /// <param name="enumType">the type of the enum</param>
        /// <param name="value">the description of the EnumValue</param>
        /// <returns></returns>
        public static T GetEnumByDescription<T>(string description)
        {
            if (description == null)
            {
                return default(T);
            }
            Type enumType = typeof(T);
            List<EnumItem> list = GetEnumItems(enumType);
            foreach (EnumItem item in list)
            {
                if (item.Value.ToString().ToLower() == description.Trim().ToLower())
                    return (T)item.Key;
            }
            return default(T);
        }
        /// <summary>
        /// get the description attribute of a Enum value
        /// </summary>
        /// <param name="enumType">the type of the enum</param>
        /// <param name="value">enum value name</param>
        /// <returns></returns>
        public static T GetEnumByName<T>(string name)
        {
            Type enumType = typeof(T);
            List<EnumItem> list = GetEnumItems(enumType);
            bool flag = false;
            foreach (EnumItem item in list)
            {
                if (item.Value.ToString().ToLower() == name.Trim().ToLower())
                {
                    flag = true;
                    return (T)item.Key;
                }
            }
            if (!flag)
            {
                throw new ArgumentException("Can not found specify the name of the enum", "name");
            }
            return default(T);
        }

        public static T GetEnumByValue<T>(object value)
        {
            bool flag = false;
            if (value == null)
                throw new ArgumentNullException("value");
            try
            {
                Type enumType = typeof(T);
                List<EnumItem> list = GetEnumItems(enumType);
                foreach (EnumItem item in list)
                {
                    if (item.Key.ToString().Trim().ToLower() == value.ToString().Trim().ToLower())
                    {
                        flag = true;
                        return (T)item.Key;
                    }
                }
                if (!flag)
                {
                    throw new ArgumentException("Can not found specify the value of the enum", "value");
                }
                return default(T);
            }
            catch
            {
                return default(T);
            }
        }
        public static int? GetValueByEnum(object value)
        {
            if (value == null)
                return null;
            try
            {
                return (int)value;
            }
            catch
            {
                return null;
            }
        }

        #endregion 

        #region Parse Enum
        /// <summary>
        /// 提供Value的字符,转换为对应的枚举对象
        /// <remarks>适用于枚举对象值定义为Char类型的</remarks>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="c"></param>
        /// <returns></returns>
        public static T Parse<T>(char c) where T : struct
        {
            return Parse<T>((ulong)c);
        }

        /// <summary>
        /// 提供Value的字符,转换为对应的枚举对象
        /// <remarks>适用于枚举对象值定义为Int类型的</remarks>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="l"></param>
        /// <returns></returns>
        public static T Parse<T>(ulong l) where T : struct
        {
            if (!typeof(T).IsEnum)
            {
                throw new ArgumentException("Need System.Enum as generic type!");
            }

            object o = Enum.Parse(typeof(T), l.ToString());
            if (Enum.IsDefined(typeof(T), o))
            {
                return (T)o;
            }

            throw new InvalidCastException();
        }

        /// <summary>
        /// 提供Value的字符,转换为对应的枚举对象
        /// <remarks>适用于枚举对象值定义为Char类型的</remarks>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        public static T Parse<T>(string value) where T : struct
        {
            if (value == null || value.Trim().Length != )
            {
                throw new ArgumentException("Invalid cast,value must be one character!");
            }

            return Parse<T>(value[]);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="c"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public static bool TryParse<T>(char c, out T result) where T : struct
        {
            return TryParse<T>((ulong)c, out result);
        }

        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public static bool TryParse<T>(string value, out T result) where T : struct
        {
            try
            {
                if (value == null || value.Trim().Length != )
                {
                    throw new ArgumentException("Invalid cast,value must be one character!");
                }

                return TryParse<T>(value[], out result);
            }
            catch
            {
                result = default(T);
                return false;
            }
        }

        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public static bool TryParse<T>(ulong value, out T result) where T : struct
        {
            try
            {
                result = Parse<T>(value);
                return true;
            }
            catch
            {
                result = default(T);
                return false;
            }
        }
        #endregion
    }

    public class EnumItem
    {

        private object m_key;
        private object m_value;

        public object Key
        {
            get { return m_key; }
            set { m_key = value; }
        }

        public object Value
        {
            get { return m_value; }
            set { m_value = value; }
        }

        public EnumItem(object _key, object _value)
        {
            m_key = _key;
            m_value = _value;
        }
    }