type - Valor numérico de enumeración de C#como cadena

obtener el valor numerico de un enum c#

Question

Tengo la siguiente enumeración:

public enum Urgency {
    VeryHigh = 1,
    High     = 2,
    Routine  = 4
}

Puedo obtener una enumeración "valor" como una cadena como esta:

((int)Urgency.Routine).ToString() // returns "4"  

Nota: Esto es diferente de:

Urgency.Routine.ToString() // returns "Routine"
(int)Urgency.Routine       // returns 4

¿Hay alguna forma en que pueda crear una clase de extensión, o una clase de utilidad estática, que proporcione algo de azúcar sintáctico? :)

Answer 1

¿Qué tal un poco de reflexión? Debería funcionar con todos los tipos subyacentes.

public static class EnumTools
{
    public static string ToRawValueString(this Enum e)
    {
        return e
            .GetType()
            .GetFields(BindingFlags.Public | BindingFlags.Static)
            .First(f => f.Name==e.ToString())
            .GetRawConstantValue()
            .ToString();
    }
}

Entonces:

Console.WriteLine(Urgency.High.ToRawValueString()); //Writes "2"

Answer 2

Con el fin de lograr más descripciones "legibles por humanos" para enumeraciones (p. Ej., "Muy alto" en lugar de "Muy alto" en su ejemplo), he decorado los valores de enumeración con el siguiente atributo:

public enum MeasurementType
{
    Each,

    [DisplayText("Lineal Metres")]
    LinealMetre,

    [DisplayText("Square Metres")]
    SquareMetre,

    [DisplayText("Cubic Metres")]
    CubicMetre,

    [DisplayText("Per 1000")]
    Per1000,

    Other
}


public class DisplayText : Attribute
{

    public DisplayText(string Text)
    {
        this.text = Text;
    }


    private string text;


    public string Text
    {
        get { return text; }
        set { text = value; }
    }
}

Luego, usamos un método de extensión como este:

    public static string ToDescription(this Enum en)
    {

        Type type = en.GetType();

        MemberInfo[] memInfo = type.GetMember(en.ToString());

        if (memInfo != null && memInfo.Length > 0)
        {

            object[] attrs = memInfo[0].GetCustomAttributes(
                                          typeof(DisplayText),

                                          false);

            if (attrs != null && attrs.Length > 0)

                return ((DisplayText)attrs[0]).Text;

        }

        return en.ToString();

    }

Usted puede simplemente llamar

myEnum.ToDescription() con el fin de mostrar su enumeración como texto más legible.

Answer 3

Genial ... ahora he agregado un método de extensión a mi proyecto

public static class EnumExtensions 
{ 
    public static string NumberString(this Enum enVal) 
    { 
        return enVal.ToString("D"); 
    }
} 

Ahora puedo obtener el valor int, como una cadena, llamando a Urgency.Routine.NumberString(); Gracias a Frankentosh y Jon :)

Answer 4

Puede escribir un método de extensión para su tipo específico:

public static class UrgencyExtension
{
    public static string ToIntegerString(this Urgency u)
    {
        return ((int)u).ToString();
    }
}

Use de la siguiente manera:

Urgency u = Urgency.Routine;
string s = u.ToIntegerString();

Answer 5

Si lo desea, puede hacer que el método de extensión funcione para todas las enumeraciones:

public static string ToValueString(this Enum enumValue) 
{
    if (enumValue.GetType().GetEnumUnderlyingType() == typeof(int))
        return ((int)(object)enumValue).ToString();
    else if (enumValue.GetType().GetEnumUnderlyingType() == typeof(byte))
        return ((byte)(object)enumValue).ToString();
    ... 
}        

Answer 6

Si solo quieres lidiar con esta enumeración, usa la solución de Mark Byer.

Para una solución más general:

public static string NumberString(this Enum enVal) 
{
    return Convert.ToDecimal(enVal).ToString("0");
}

Convertir a decimal significa que no necesita tratar con los 8 diferentes tipos de integrales subyacentes permitidos de manera explícita, ya que todos ellos se convierten sin pérdida a decimal pero no entre sí (tanto el largo como el largo no se convierten sin pérdida entre sí, pero ambos pueden manejarse todo el resto). Hacer eso probablemente sería más rápido (especialmente si escoge bien en su orden de comparación), pero mucho más detallado para una ganancia relativamente pequeña.

Editar:

Sin embargo, lo anterior no es tan bueno como el de Frankentosh, Frankentosh vio a través de la pregunta el problema real y lo resuelve de manera muy elocuente.

Answer 7

Solo debe poder usar las sobrecargas del método Enums ToString para darle una cadena de formato, esto imprimirá el valor de la enumeración como una cadena.

public static class Program
{
    static void Main(string[] args)
    {
        var val = Urgency.High;
        Console.WriteLine(val.ToString("D")); 
    }
}

public enum Urgency 
{ 
    VeryHigh = 1,
    High = 2,
    Low = 4
}