c# - switch - Convierte enums a valores legibles por humanos

enum to list c#

Question

¿Alguien sabe cómo transformar un valor enum a un valor humano legible?

Por ejemplo:

ThisIsValueA debería ser "This is Value A".

Answer 1

TheToString on Enums es relativamente lento en C #, comparable con GetType (). Name (incluso podría usarlo bajo las carátulas).

Si su solución necesita ser muy rápida o altamente eficiente, es mejor que guarde sus conversiones en un diccionario estático y las busque desde allí.

Una pequeña adaptación del código de @ Leon para aprovechar C # 3. Esto tiene sentido como una extensión de las enumeraciones: puede limitar esto al tipo específico si no quiere saturarlas todas.

public static string Wordify(this Enum input)
{            
    Regex r = new Regex("(?<=[a-z])(?<x>[A-Z])|(?<=.)(?<x>[A-Z])(?=[a-z])");
    return r.Replace( input.ToString() , " ${x}");
}

//then your calling syntax is down to:
MyEnum.ThisIsA.Wordify();

Answer 2

Convertir esto de un fragmento de código vb que un determinado Ian Horwill dejó en una publicación de blog hace mucho tiempo ... desde entonces he usado esto en la producción con éxito.

    /// <summary>
    /// Add spaces to separate the capitalized words in the string, 
    /// i.e. insert a space before each uppercase letter that is 
    /// either preceded by a lowercase letter or followed by a 
    /// lowercase letter (but not for the first char in string). 
    /// This keeps groups of uppercase letters - e.g. acronyms - together.
    /// </summary>
    /// <param name="pascalCaseString">A string in PascalCase</param>
    /// <returns></returns>
    public static string Wordify(string pascalCaseString)
    {            
        Regex r = new Regex("(?<=[a-z])(?<x>[A-Z])|(?<=.)(?<x>[A-Z])(?=[a-z])");
        return r.Replace(pascalCaseString, " ${x}");
    }

(requiere, ''using System.Text.RegularExpressions;'')

Así:

Console.WriteLine(Wordify(ThisIsValueA.ToString()));

Volvería,

"This Is Value A".

Es mucho más simple y menos redundante que proporcionar atributos de Descripción.

Los atributos son útiles aquí solo si necesita proporcionar una capa de indirección (que la pregunta no solicitó).

Answer 3

La mayoría de los ejemplos de esto que he visto implican marcar los valores enum con los atributos [Descripción] y usar la reflexión para hacer la "conversión" entre el valor y la descripción. Aquí hay una vieja publicación en el blog sobre esto:

http://geekswithblogs.net/rakker/archive/2006/05/19/78952.aspx

Answer 4

Me pareció mejor definir tus valores enum con un puntaje inferior, así ThisIsValueA sería This_Is_Value_A, entonces puedes hacer un enumValue.toString (). Replace ("_", "") donde enumValue es tu varible.

Answer 5

También puede echar un vistazo a este artículo: http://www.codeproject.com/KB/cs/enumdatabinding.aspx

Se trata específicamente de enlace de datos, pero muestra cómo usar un atributo para decorar los valores enum y proporciona un método "GetDescription" para recuperar el texto del atributo. El problema con el uso del atributo de descripción incorporado es que existen otros usos / usuarios de ese atributo, por lo que existe la posibilidad de que la descripción aparezca donde no lo desee. El atributo personalizado resuelve ese problema.

Answer 6

Puede heredar de la clase "Atributo" de System.Reflection para crear su propia clase "Descripción". Me gusta esto (de aquí ):

using System;
using System.Reflection;
namespace FunWithEnum
{
    enum Coolness : byte
    {
        [Description("Not so cool")]
        NotSoCool = 5,
        Cool, // since description same as ToString no attr are used
        [Description("Very cool")]
        VeryCool = NotSoCool + 7,
        [Description("Super cool")]
        SuperCool
    }
    class Description : Attribute
    {
        public string Text;
        public Description(string text)
        {
            Text = text;
        }
    }
    class Program
    {
        static string GetDescription(Enum en)
        {
            Type type = en.GetType();
            MemberInfo[] memInfo = type.GetMember(en.ToString());
            if (memInfo != null && memInfo.Length > 0)
            {
                object[] attrs = memInfo[0].GetCustomAttributes(typeof(Description), false);
                if (attrs != null && attrs.Length > 0)
                    return ((Description)attrs[0]).Text;
            }
            return en.ToString();
        }
        static void Main(string[] args)
        {
            Coolness coolType1 = Coolness.Cool;
            Coolness coolType2 = Coolness.NotSoCool;
            Console.WriteLine(GetDescription(coolType1));
            Console.WriteLine(GetDescription(coolType2));
        }
    }
}