Enum | Template de código | C#

• Enum | Template de código | C#

TÓPICOS: exemplos de uso

Helpers

        /// <summary>
        /// Obter a descrição de um enum.
        /// </summary>
        /// <typeparam name="T">Enum, com descrição.</typeparam>
        /// <param name="e">Enum com descrição a ser obtida</param>
        /// <returns>Obter a descrição de um enum.</returns>
        public static string GetDescription<T>(this T e) where T : IConvertible
        {
            if (e is Enum)
            {
                var type = e.GetType();
                var values = System.Enum.GetValues(type);

                foreach (int val in values)
                {
                    if (val == e.ToInt32(CultureInfo.InvariantCulture))
                    {
                        var memInfo = type.GetMember(type.GetEnumName(val));
                        var descriptionAttribute = memInfo[0]
                            .GetCustomAttributes(typeof(DescriptionAttribute), false)
                            .FirstOrDefault() as DescriptionAttribute;

                        if (descriptionAttribute != null)
                        {
                            return descriptionAttribute.Description;
                        }
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Obter um valor de enum com base na descrição.
        /// </summary>
        /// <typeparam name="T">Enum, com descrição.</typeparam>
        /// <param name="e">Descrição para obter valor</param>
        /// <returns>Obter um valor de enum com base na descrição.</returns>
        public static T GetValueByDescription<T>(string description) where T : Enum
        {
            foreach (var field in typeof(T).GetFields())
            {
                if (Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) is DescriptionAttribute attribute)
                {
                    if (attribute.Description == description)
                        return (T)field.GetValue(null);
                }
                else
                {
                    if (field.Name == description)
                        return (T)field.GetValue(null);
                }
            }

            return default(T);
        }

        /// <summary>
        /// Obter todas as description do enum
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns>Retorna uma tupla de codigo e nome</returns>
        public static System.Collections.Generic.List<Tuple<int, string>> GetValuesDescription<T>() where T : struct, IConvertible
        {
            if (!typeof(T).IsEnum)
                return new System.Collections.Generic.List<Tuple<int, string>>();

            return Enum.GetValues(typeof(T))
            .Cast<T>()
            .Select(x => Tuple.Create(Convert.ToInt32(x), GetDescription(x))).ToList();
        }

        /// <summary>
        /// Obter todas as description do enum através de uma lista de T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns>Retorna uma lista de String</returns>
        public static List<string> GetDescriptionByList<T, T1>(System.Collections.Generic.List<T1> list) where T : Enum
        {
            if (!Funcoes.ListaPreenchida(list)) return new List<string>() { };

            var enumList = Enum.GetValues(typeof(T)).Cast<T>().ToList();

            var enumNumber = enumList.Intersect(list.Cast<T>());

            var listOfDescription = new System.Collections.Generic.List<string>();

            foreach (var itemEnum in enumNumber.Where(x => !string.IsNullOrEmpty(GetDescription(x))))
                listOfDescription.Add(GetDescription(itemEnum));

            return listOfDescription;
        }

        /// <summary>
        /// Obter todos os valores do enums
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns>Retorna uma lista de T1</returns>
        public static List<T1> GetValues<T, T1>() where T : Enum
        {

            if (!typeof(T).GetEnumUnderlyingType().Name.Equals(typeof(T1).Name))
                return new List<T1>();

            var listOfValues = new List<T1>();

            foreach (T1 item in Enum.GetValues(typeof(T)))
                listOfValues.Add(item);

            return listOfValues;
        }

        /// <summary>
        /// Obter quantidade de valores dentro do enum
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns>Retorna um Integer</returns>
        public static int GetLength<T>() where T : Enum
            => Enum.GetValues(typeof(T)).Length;

        public static object ObterAtributo<TAtributo>(this Enum e) where TAtributo : Atributo
        {
            var tipo = e.GetType();
            var valores = Enum.GetValues(tipo);

            foreach (int valor in valores)
            {
                if (valor == Convert.ToInt32(e))
                {
                    var memberInfo = tipo.GetMember(tipo.GetEnumName(valor));

                    var atributo = memberInfo[0]
                        .GetCustomAttributes(typeof(TAtributo), inherit: false)
                        .FirstOrDefault() as TAtributo;

                    if (atributo != null)
                        return atributo.Valor;
                }
            }

            return null;
        }

Extensions | C#

// Simples
public static class StringEnum
{
    public static T ToEnum<T>(this string value)
    {
        return (T)Enum.Parse(typeof(T), value, true);
    }
}

// Robusto
public static T ToEnum<T>(this string value, T defaultValue) 
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    T result;
    return Enum.TryParse<T>(value, true, out result) ? result : defaultValue;
}