String reprezentacja Enum

Użyj metody

Enum.GetName(Type MyEnumType,  object enumvariable)  

Jak w (Załóżmy, że Shipper jest zdefiniowanym Enum)

Shipper x = Shipper.FederalExpress;
string s = Enum.GetName(typeof(Shipper), x);

Jest kilka innych statycznych metod na klasie Enum, które warto zbadać...

Możesz odwoływać się do nazwy, a nie do wartości, używając ToString ()

Console.WriteLine("Auth method: {0}", AuthenticationMethod.Forms.ToString());

Dokumentacja jest tutaj:

Http://msdn.microsoft.com/en-us/library/16c1xs4z.aspx

...a jeśli nazwiesz swoje enums w przypadku Pascala (tak jak ja - np. ThisIsMyEnumValue = 1 itd.) następnie możesz użyć bardzo prostego wyrażenia regularnego do wydrukowania przyjaznego formularza:

static string ToFriendlyCase(this string EnumString)
{
    return Regex.Replace(EnumString, "(?!^)([A-Z])", " $1");
}

Które można łatwo wywołać z dowolnego ciągu znaków:

Console.WriteLine("ConvertMyCrazyPascalCaseSentenceToFriendlyCase".ToFriendlyCase());

Wyjścia:

Convert My Crazy Pascal Case Sentence To Friendly Case

To oszczędza bieganie po domach tworzenie niestandardowych atrybutów i dołączanie ich do Twoich enum lub za pomocą tabel wyszukiwania, aby połączyć wartość enum z przyjaznym ciągiem, a najlepsze jest to samo zarządzanie i może być używane na każdym Pascalu Case string, który jest nieskończenie bardziej wielokrotnego użytku. Oczywiście nie pozwala to na posiadanie innej przyjaznej nazwy niż Twoje enum, które zapewnia Twoje rozwiązanie.

I do like your oryginalne rozwiązanie dla bardziej złożonych scenariuszy. Możesz wziąć swoje rozwiązanie o krok dalej i uczynić GetStringValue metodą rozszerzenia swojego enum, a następnie nie musisz odwoływać się do niego jak StringEnum.GetStringValue...

public static string GetStringValue(this AuthenticationMethod value)
{
  string output = null;
  Type type = value.GetType();
  FieldInfo fi = type.GetField(value.ToString());
  StringValue[] attrs = fi.GetCustomAttributes(typeof(StringValue), false) as StringValue[];
  if (attrs.Length > 0)
    output = attrs[0].Value;
  return output;
}

Możesz wtedy łatwo uzyskać do niego dostęp bezpośrednio z instancji enum:

Console.WriteLine(AuthenticationMethod.SSO.GetStringValue());

Niestety refleksja nad uzyskaniem atrybutów na enumach jest dość powolna:

Zobacz to pytanie: ktoś zna szybki sposób, aby dostać się do niestandardowych atrybutów na wartości enum?

.ToString() jest również dość powolny na enumach.

Możesz jednak napisać metody rozszerzeń dla enum:

public static string GetName( this MyEnum input ) {
    switch ( input ) {
        case MyEnum.WINDOWSAUTHENTICATION:
            return "Windows";
        //and so on
    }
}

To nie jest świetne, ale będzie szybkie i nie będzie wymagało odbicia dla atrybutów lub nazwy pola.

C # 6 Update

Jeśli możesz używać C # 6 to nowy nameof operator działa dla enum, więc nameof(MyEnum.WINDOWSAUTHENTICATION) zostanie przekonwertowany na "WINDOWSAUTHENTICATION" w czasie kompilacji, co czyni go najszybszym sposobem uzyskania nazw enum.

Zauważ, że spowoduje to konwersję jawnego enum na stałą inlined, więc nie działa dla enum, które masz w zmiennej. Więc:

nameof(AuthenticationMethod.FORMS) == "FORMS"

var myMethod = AuthenticationMethod.FORMS;
nameof(myMethod) == "myMethod"

Używam metody rozszerzenia:

public static class AttributesHelperExtension
    {
        public static string ToDescription(this Enum value)
        {
            var da = (DescriptionAttribute[])(value.GetType().GetField(value.ToString())).GetCustomAttributes(typeof(DescriptionAttribute), false);
            return da.Length > 0 ? da[0].Description : value.ToString();
        }
}

Teraz udekoruj enum z:

public enum AuthenticationMethod
{
    [Description("FORMS")]
    FORMS = 1,
    [Description("WINDOWSAUTHENTICATION")]
    WINDOWSAUTHENTICATION = 2,
    [Description("SINGLESIGNON ")]
    SINGLESIGNON = 3
}

Kiedy zadzwonisz

AuthenticationMethod.FORMS.ToDescription() dostaniesz "FORMS".

Po prostu użyj metody ToString()

public enum any{Tomato=0,Melon,Watermelon}

Aby odwołać się do ciągu Tomato, wystarczy użyć

any.Tomato.ToString();

Używam atrybutu Description z systemu.Przestrzeń nazw ComponentModel. Po prostu udekoruj enum, a następnie użyj tego kodu, aby go odzyskać:

public static string GetDescription<T>(this object enumerationValue)
            where T : struct
        {
            Type type = enumerationValue.GetType();
            if (!type.IsEnum)
            {
                throw new ArgumentException("EnumerationValue must be of Enum type", "enumerationValue");
            }

            //Tries to find a DescriptionAttribute for a potential friendly name
            //for the enum
            MemberInfo[] memberInfo = type.GetMember(enumerationValue.ToString());
            if (memberInfo != null && memberInfo.Length > 0)
            {
                object[] attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);

                if (attrs != null && attrs.Length > 0)
                {
                    //Pull out the description value
                    return ((DescriptionAttribute)attrs[0]).Description;
                }
            }
            //If we have no description attribute, just return the ToString of the enum
            return enumerationValue.ToString();

        }

Jako przykład:

public enum Cycle : int
{        
   [Description("Daily Cycle")]
   Daily = 1,
   Weekly,
   Monthly
}

Ten kod dobrze odpowiada enumom, w których nie potrzebujesz "przyjaznej nazwy" i zwrócisz tylko .ToString () z enum.