Enum a Lista con los atributos

Una ventaja de utilizar enumerables es la falicidad de lectura del ccódigo. Pero su pequeña descentaja es que para los nombre de las opciones no se pueden utilizar espacios. Una forma para solucionar esto es utilizar atributos, en especial el atributo display. Pero esto no nos sirve de mucho cuando intenamos mostrar, por ejemplo, en una página web MVC con el helper de crear una lista desplegable con las opciones desde el enumeral.

Además, en ocasionies, pueded que no tengas a dicho enumera como propiedad en tu modelo, pero lo necesites para realizar elgún tipo de selección en la vista y, en función de la selección del usuario, realizar algún cambio en el DOM   de la página HTML. Hoy te traigo un truco para poder solucionar esto.

SelectEnum

Es sólo un nombre, puedes poner el nombre que más te guste. Yo lo he llamado así ya que siempre lo utiliso en para seleccionar desde una enumeración.

public static class SelectEnum where T : struct, Enum // This constraint requires C# 7.3 or later.
    {
        public static IList GetValues()
        {
            List enumValues = new ();
            Type model = typeof(T);
            FieldInfo[] fields = model.GetFields(BindingFlags.Static | BindingFlags.Public);
            foreach (FieldInfo fi in fields)
            {
                enumValues.Add((T)Enum.Parse(model, fi.Name, false));                
            }
            return enumValues;
        }

        public static T Parse(string value)
        {
            return (T)Enum.Parse(typeof(T), value, true);
        }

        public static IList GetNames(Enum value)
        {
            return value.GetType().GetFields(BindingFlags.Static | BindingFlags.Public).Select(fi => fi.Name).ToList();
        }

        public static IList GetDisplayValues(Enum value)
        {
            return GetNames(value).Select(obj => GetDisplayValue(Parse(obj))).ToList();
        }

        private static string lookupResource(Type resourceManagerProvider, string resourceKey)
        {
            PropertyInfo resourceKeyProperty = resourceManagerProvider.GetProperty(resourceKey,
                BindingFlags.Static | BindingFlags.Public, null, typeof(string),
                new Type[0], null);
            if (resourceKeyProperty != null)
            {
                return (string)resourceKeyProperty.GetMethod.Invoke(null, null);
            }

            return resourceKey; // Fallback with the key name
        }

        public static string GetDisplayValue(T value)
        {
            FieldInfo fieldInfo = value.GetType().GetField(value.ToString());

            DisplayAttribute[] descriptionAttributes = fieldInfo.GetCustomAttributes(
                typeof(DisplayAttribute), false) as DisplayAttribute[];

            string result;
            if (descriptionAttributes.Length > 0)
            {
                if (descriptionAttributes[0].ResourceType != null)
                    result = lookupResource(descriptionAttributes[0].ResourceType, descriptionAttributes[0].Name);
                else
                    result = (descriptionAttributes.Length > 0) ? descriptionAttributes[0].Name : value.ToString();
            }
            else
                result = value.ToString();
            return result;
        }
    }

GetValues: Éste es el método que nos va a proporcionar todas las opciones del enumerable. Hacemos uso de System.Reflection por lo que hay que imporat el espacio de nombres.

GetDisplayValue(T value): Con éste otro método recuperaremos el nombre desde el atributo display, o en su defecto, el nombre de la propiedad.

Básicamente éstos son los dós métodos a utilizar, pero hay otros que pueden ser de utilidad.

Como utilizarlo

Principalmente he utilizado este truco para usarlo desde páginas MVC, pero puede ser utilizado desde cualquier aplicación C#, ya que estamos convirtiendo un Enum en un List y esto es compatible con cualquier aplicación C#.

< select>
    @foreach (APIIntegration value in SelectEnum<[Enum a usar]>.GetValues())
    {
     < option value="@((int)value)"> @(SelectEnum<[Enum a usar]>.GetDisplayValue(value))     
    }                                              
< /select>

Compo puede ver es bastante fácil de usar. Y una vez implementado apenas son 4 líneas de código. Espero que os haya gustado este truco rápido hoy.

Happy Coding