Conversión de enumeraciones a valores legibles por humanos

Question

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

Por ejemplo:

ThisIsValueA debe ser "Este es el valor A".

Answer 1

conversión de esto desde un código vb fragmento de código que un cierto Ian Horwill a la izquierda en una blog post long ago ... ya que he utilizado este éxito en la producción.

/// <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, 'usando System.Text.RegularExpressions;')

Por lo tanto:

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 2

La mayoría de ejemplos de esto que he visto implican marcar sus valores enum con los atributos [Descripción] y usar la reflexión para hacer la "conversión" entre el valor y la descripción. He aquí un antiguo blog post sobre ello:

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

Answer 3

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

Es específicamente sobre el enlace de datos, sino que muestra cómo utilizar un atributo para decorar los valores de enumeración 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 4

Puede heredar de la clase "Atributo" de System.Reflection para crear su propia clase "Descripción". Como esto (de here):

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)); 
     } 
    } 
} 

Answer 5

Me pareció mejor definir sus valores enum con un puntaje inferior para que ThisIsValueA sea This_Is_Value_A, entonces usted puede simplemente hacer un enumValue.toString(). Reemplazar ("_", "") donde enumValue es su varible.

Answer 6

.ToString en Enums es relativamente lento en C#, comparable con GetType(). Nombre (incluso podría usar eso debajo de las cubiertas).

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();