W jaki sposób mogę mieć skojarzony wyliczenie combobox z niestandardowym formatowaniem ciągu dla wartości wyliczenia?

W poście Enum ToString metoda jest opisana w celu użycia atrybutu niestandardowego w DescriptionAttributenastępujący sposób:

Enum HowNice {
  [Description("Really Nice")]
  ReallyNice,
  [Description("Kinda Nice")]
  SortOfNice,
  [Description("Not Nice At All")]
  NotNice
}

Następnie wywołujesz funkcję GetDescription, używając składni takiej jak:

GetDescription<HowNice>(NotNice); // Returns "Not Nice At All"

Ale to nie pomaga mi, gdy chcę po prostu wypełnić ComboBox wartościami wyliczenia, ponieważ nie mogę zmusić ComboBox do wywołaniaGetDescription .

To, czego chcę, ma następujące wymagania:

• Odczyt (HowNice)myComboBox.selectedItemzwróci wybraną wartość jako wartość wyliczenia.
• Użytkownik powinien widzieć przyjazne dla użytkownika łańcuchy wyświetlania, a nie tylko nazwy wartości wyliczenia. Zamiast więc zobaczyć „ NotNice”, użytkownik zobaczy „ Not Nice At All”.
• Miejmy nadzieję, że rozwiązanie będzie wymagało minimalnych zmian kodu w istniejących wyliczeniach.

Oczywiście mógłbym zaimplementować nową klasę dla każdego wyliczenia, które utworzę, i zastąpić jej ToString(), ale to dużo pracy dla każdego wyliczenia i wolałbym tego uniknąć.

Jakieś pomysły?

Cholera, nawet przytulę jako nagrodę :-)

Możesz napisać TypeConverter, który odczytuje określone atrybuty, aby wyszukać je w zasobach. W ten sposób bez większego kłopotu uzyskasz obsługę wielu języków dla wyświetlanych nazw.

Zapoznaj się z metodami ConvertFrom / ConvertTo TypeConverter i użyj odbicia, aby odczytać atrybuty w polach wyliczenia .

ComboBoxma wszystko, czego potrzebujesz: FormattingEnabledwłaściwość, którą powinieneś ustawić true, i Formatzdarzenie, w którym musisz umieścić żądaną logikę formatowania. A zatem,

myComboBox.FormattingEnabled = true;
myComboBox.Format += delegate(object sender, ListControlConvertEventArgs e)
    {
        e.Value = GetDescription<HowNice>((HowNice)e.Value);
    }

Nie! Wyliczenia są prymitywami, a nie obiektami UI - uczynienie ich obsługi UI w .ToString () byłoby bardzo złe z punktu widzenia projektowania. Próbujesz tutaj rozwiązać niewłaściwy problem: prawdziwy problem polega na tym, że nie chcesz, aby Enum.ToString () pojawiało się w polu kombi!

Teraz jest to rzeczywiście bardzo możliwy do rozwiązania problem! Tworzysz obiekt UI reprezentujący elementy z pola kombi:

sealed class NicenessComboBoxItem
{
    public string Description { get { return ...; } }
    public HowNice Value { get; private set; }

    public NicenessComboBoxItem(HowNice howNice) { Value = howNice; }
}

Następnie po prostu dodaj wystąpienia tej klasy do kolekcji Items pola kombi i ustaw następujące właściwości:

comboBox.ValueMember = "Value";
comboBox.DisplayMember = "Description";

TypeConverter. Myślę, że właśnie tego szukałem. Witajcie, Simon Svensson !

[TypeConverter(typeof(EnumToStringUsingDescription))]
Enum HowNice {
  [Description("Really Nice")]
  ReallyNice,
  [Description("Kinda Nice")]
  SortOfNice,
  [Description("Not Nice At All")]
  NotNice
}

Wszystko, co muszę zmienić w moim bieżącym wyliczeniu, to dodać tę linię przed ich deklaracją.

[TypeConverter(typeof(EnumToStringUsingDescription))]

Gdy to zrobię, każde wyliczenie zostanie wyświetlone przy użyciu DescriptionAttributejego pól.

Aha, i TypeConverterbyłoby to zdefiniowane w ten sposób:

public class EnumToStringUsingDescription : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return (sourceType.Equals(typeof(Enum)));
    }

    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
    {
        return (destinationType.Equals(typeof(String)));
    }

    public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
    {
        return base.ConvertFrom(context, culture, value);
    }

    public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
    {
        if (!destinationType.Equals(typeof(String)))
        {
            throw new ArgumentException("Can only convert to string.", "destinationType");
        }

        if (!value.GetType().BaseType.Equals(typeof(Enum)))
        {
            throw new ArgumentException("Can only convert an instance of enum.", "value");
        }

        string name = value.ToString();
        object[] attrs = 
            value.GetType().GetField(name).GetCustomAttributes(typeof(DescriptionAttribute), false);
        return (attrs.Length > 0) ? ((DescriptionAttribute)attrs[0]).Description : name;
    }
}

Pomaga mi to w przypadku mojej skrzynki ComboBox, ale oczywiście w rzeczywistości nie zastępuje ToString(). W międzyczasie zgodzę się na to ...

Na podstawie przykładu wyliczenia:

using System.ComponentModel;

Enum HowNice
{
    [Description("Really Nice")]
    ReallyNice,
    [Description("Kinda Nice")]
    SortOfNice,
    [Description("Not Nice At All")]
    NotNice
}

Utwórz rozszerzenie:

public static class EnumExtensions
{
    public static string Description(this Enum value)
    {
        var enumType = value.GetType();
        var field = enumType.GetField(value.ToString());
        var attributes = field.GetCustomAttributes(typeof(DescriptionAttribute),
                                                   false);
        return attributes.Length == 0
            ? value.ToString()
            : ((DescriptionAttribute)attributes[0]).Description;
    }
}

Następnie możesz użyć czegoś takiego jak:

HowNice myEnum = HowNice.ReallyNice;
string myDesc = myEnum.Description();

Więcej informacji można znaleźć pod adresem : http://www.blackwasp.co.uk/EnumDescription.aspx . Rozwiązanie należy do Richrda Carra

Możesz stworzyć ogólną strukturę, której możesz użyć dla wszystkich swoich wyliczeń, które mają opisy. Dzięki niejawnym konwersjom do iz klasy zmienne nadal działają jak wyliczenie, z wyjątkiem metody ToString:

public struct Described<T> where T : struct {

    private T _value;

    public Described(T value) {
        _value = value;
    }

    public override string ToString() {
        string text = _value.ToString();
        object[] attr =
            typeof(T).GetField(text)
            .GetCustomAttributes(typeof(DescriptionAttribute), false);
        if (attr.Length == 1) {
            text = ((DescriptionAttribute)attr[0]).Description;
        }
        return text;
    }

    public static implicit operator Described<T>(T value) {
        return new Described<T>(value);
    }

    public static implicit operator T(Described<T> value) {
        return value._value;
    }

}

Przykład użycia:

Described<HowNice> nice = HowNice.ReallyNice;

Console.WriteLine(nice == HowNice.ReallyNice); // writes "True"
Console.WriteLine(nice); // writes "Really Nice"

Myślę, że nie da się tego zrobić bez prostego wiązania się z innym typem - przynajmniej nie jest to wygodne. Normalnie, nawet jeśli nie możesz kontrolować ToString(), możesz użyć a, TypeConverteraby wykonać niestandardowe formatowanie - ale IIRC System.ComponentModelnie uwzględnia tego w przypadku wyliczeń.

Możesz powiązać się z jednym string[]z opisów lub czymś zasadniczo podobnym do pary klucz / wartość? (opis / wartość) - coś takiego:

class EnumWrapper<T> where T : struct
{
    private readonly T value;
    public T Value { get { return value; } }
    public EnumWrapper(T value) { this.value = value; }
    public string Description { get { return GetDescription<T>(value); } }
    public override string ToString() { return Description; }

    public static EnumWrapper<T>[] GetValues()
    {
        T[] vals = (T[])Enum.GetValues(typeof(T));
        return Array.ConvertAll(vals, v => new EnumWrapper<T>(v));
    }
}

A następnie powiąż z EnumWrapper<HowNice>.GetValues()

Najlepszym sposobem na to jest utworzenie klasy.

class EnumWithToString {
    private string description;
    internal EnumWithToString(string desc){
        description = desc;
    }
    public override string ToString(){
        return description;
    }
}

class HowNice : EnumWithToString {

    private HowNice(string desc) : base(desc){}

    public static readonly HowNice ReallyNice = new HowNice("Really Nice");
    public static readonly HowNice KindaNice = new HowNice("Kinda Nice");
    public static readonly HowNice NotVeryNice = new HowNice("Really Mean!");
}

Uważam, że to najlepszy sposób na zrobienie tego.

Po umieszczeniu w comboboxach ładny ToString zostanie pokazany, a fakt, że nikt nie może utworzyć więcej instancji twojej klasy, zasadniczo sprawia, że ​​jest to wyliczenie.

ps może zaistnieć potrzeba drobnych poprawek składni, nie jestem zbyt dobry z C #. (Facet Java)

Biorąc pod uwagę, że wolisz nie tworzyć klasy dla każdego wyliczenia, polecam utworzenie słownika wartości wyliczenia / wyświetlanego tekstu i powiązanie go.

Zauważ, że ma to zależność od metod metody GetDescription w oryginalnym poście.

public static IDictionary<T, string> GetDescriptions<T>()
    where T : struct
{
    IDictionary<T, string> values = new Dictionary<T, string>();

    Type type = enumerationValue.GetType();
    if (!type.IsEnum)
    {
        throw new ArgumentException("T must be of Enum type", "enumerationValue");
    }

    //Tries to find a DescriptionAttribute for a potential friendly name
    //for the enum
    foreach (T value in Enum.GetValues(typeof(T)))
    {
        string text = value.GetDescription();

        values.Add(value, text);
    }

    return values;
}

Nie można zastąpić ToString () wyliczeń w języku C #. Możesz jednak użyć metod rozszerzających;

public static string ToString(this HowNice self, int neverUsed)
{
    switch (self)
    {
        case HowNice.ReallyNice:
            return "Rilly, rilly nice";
            break;
    ...

Oczywiście będziesz musiał wykonać jawne wywołanie metody, tj;

HowNice.ReallyNice.ToString(0)

To nie jest miłe rozwiązanie, z instrukcją przełącznika i wszystkim - ale powinno działać i, miejmy nadzieję, bez wielu przeróbek ...

Idąc za odpowiedzią @scraimer, oto wersja konwertera typu wyliczenie na ciąg, który również obsługuje flagi:

    /// <summary>
/// A drop-in converter that returns the strings from 
/// <see cref="System.ComponentModel.DescriptionAttribute"/>
/// of items in an enumaration when they are converted to a string,
/// like in ToString().
/// </summary>
public class EnumToStringUsingDescription : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return (sourceType.Equals(typeof(Enum)));
    }

    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
    {
        return (destinationType.Equals(typeof(String)));
    }

    public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
    {
        return base.ConvertFrom(context, culture, value);
    }

    public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
    {
        if (destinationType.Equals(typeof(String)))
        {
            string name = value.ToString();
            Type effectiveType = value.GetType();          

            if (name != null)
            {
                FieldInfo fi = effectiveType.GetField(name);
                if (fi != null)
                {
                    object[] attrs =
                    fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    return (attrs.Length > 0) ? ((DescriptionAttribute)attrs[0]).Description : name;
                }

            }
        }

        return base.ConvertTo(context, culture, value, destinationType);
    }

    /// <summary>
    /// Coverts an Enums to string by it's description. falls back to ToString.
    /// </summary>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    public string EnumToString(Enum value)
    {
        //getting the actual values
        List<Enum> values = EnumToStringUsingDescription.GetFlaggedValues(value);
        //values.ToString();
        //Will hold results for each value
        List<string> results = new List<string>();
        //getting the representing strings
        foreach (Enum currValue in values)
        {
            string currresult = this.ConvertTo(null, null, currValue, typeof(String)).ToString();;
            results.Add(currresult);
        }

        return String.Join("\n",results);

    }

    /// <summary>
    /// All of the values of enumeration that are represented by specified value.
    /// If it is not a flag, the value will be the only value retured
    /// </summary>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    private static List<Enum> GetFlaggedValues(Enum value)
    {
        //checking if this string is a flaged Enum
        Type enumType = value.GetType();
        object[] attributes = enumType.GetCustomAttributes(true);
        bool hasFlags = false;
        foreach (object currAttibute in attributes)
        {
            if (enumType.GetCustomAttributes(true)[0] is System.FlagsAttribute)
            {
                hasFlags = true;
                break;
            }
        }
        //If it is a flag, add all fllaged values
        List<Enum> values = new List<Enum>();
        if (hasFlags)
        {
            Array allValues = Enum.GetValues(enumType);
            foreach (Enum currValue in allValues)
            {
                if (value.HasFlag(currValue))
                {
                    values.Add(currValue);
                }
            }



        }
        else//if not just add current value
        {
            values.Add(value);
        }
        return values;
    }

}

I metoda rozszerzenia do korzystania z niego:

    /// <summary>
    /// Converts an Enum to string by it's description. falls back to ToString
    /// </summary>
    /// <param name="enumVal">The enum val.</param>
    /// <returns></returns>
    public static string ToStringByDescription(this Enum enumVal)
    {
        EnumToStringUsingDescription inter = new EnumToStringUsingDescription();
        string str = inter.EnumToString(enumVal);
        return str;
    }

Napisałbym klasę ogólną do użytku z dowolnym typem. W przeszłości użyłem czegoś takiego:

public class ComboBoxItem<T>
{
    /// The text to display.
    private string text = "";
    /// The associated tag.
    private T tag = default(T);

    public string Text
    {
        get
        {
            return text;
        }
    }

    public T Tag
    {
        get
        {
            return tag;
        }
    }

    public override string ToString()
    {
        return text;
    }

    // Add various constructors here to fit your needs
}

Oprócz tego możesz dodać statyczną „metodę fabryczną”, aby utworzyć listę elementów combobox z podanym typem wyliczenia (prawie tak samo jak metoda GetDescriptions, którą tam masz). Oszczędziłoby to konieczności implementowania jednej encji dla każdego typu wyliczenia, a także zapewniło ładne / logiczne miejsce dla metody pomocniczej „GetDescriptions” (osobiście nazwałbym to FromEnum (T obj) ...

Utwórz kolekcję zawierającą to, czego potrzebujesz (na przykład proste obiekty zawierające Valuewłaściwość zawierającą HowNicewartość wyliczenia oraz Descriptionwłaściwość zawierającą GetDescription<HowNice>(Value)i powiązaną z danymi kombi do tej kolekcji.

Trochę tak:

Combo.DataSource = new EnumeratedValueCollection<HowNice>();
Combo.ValueMember = "Value";
Combo.DisplayMember = "Description";

kiedy masz taką klasę kolekcji:

using System;
using System.Linq;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace Whatever.Tickles.Your.Fancy
{
    public class EnumeratedValueCollection<T> : ReadOnlyCollection<EnumeratedValue<T>>
    {
        public EnumeratedValueCollection()
            : base(ListConstructor()) { }
        public EnumeratedValueCollection(Func<T, bool> selection)
            : base(ListConstructor(selection)) { }
        public EnumeratedValueCollection(Func<T, string> format)
            : base(ListConstructor(format)) { }
        public EnumeratedValueCollection(Func<T, bool> selection, Func<T, string> format)
            : base(ListConstructor(selection, format)) { }
        internal EnumeratedValueCollection(IList<EnumeratedValue<T>> data)
            : base(data) { }

        internal static List<EnumeratedValue<T>> ListConstructor()
        {
            return ListConstructor(null, null);
        }

        internal static List<EnumeratedValue<T>> ListConstructor(Func<T, string> format)
        {
            return ListConstructor(null, format);
        }

        internal static List<EnumeratedValue<T>> ListConstructor(Func<T, bool> selection)
        {
            return ListConstructor(selection, null);
        }

        internal static List<EnumeratedValue<T>> ListConstructor(Func<T, bool> selection, Func<T, string> format)
        {
            if (null == selection) selection = (x => true);
            if (null == format) format = (x => GetDescription<T>(x));
            var result = new List<EnumeratedValue<T>>();
            foreach (T value in System.Enum.GetValues(typeof(T)))
            {
                if (selection(value))
                {
                    string description = format(value);
                    result.Add(new EnumeratedValue<T>(value, description));
                }
            }
            return result;
        }

        public bool Contains(T value)
        {
            return (Items.FirstOrDefault(item => item.Value.Equals(value)) != null);
        }

        public EnumeratedValue<T> this[T value]
        {
            get
            {
                return Items.First(item => item.Value.Equals(value));
            }
        }

        public string Describe(T value)
        {
            return this[value].Description;
        }
    }

    [System.Diagnostics.DebuggerDisplay("{Value} ({Description})")]
    public class EnumeratedValue<T>
    {
        private T value;
        private string description;
        internal EnumeratedValue(T value, string description) {
            this.value = value;
            this.description = description;
        }
        public T Value { get { return this.value; } }
        public string Description { get { return this.description; } }
    }

}

Jak widać, tę kolekcję można łatwo dostosować za pomocą lambda, aby wybrać podzbiór stringmodułu wyliczającego i / lub zaimplementować niestandardowe formatowanie zamiast używać wspomnianej GetDescription<T>(x)funkcji.

Możesz użyć PostSharp do kierowania Enum.ToString i dodania dodatkowego kodu, który chcesz. Nie wymaga to żadnych zmian w kodzie.

To, czego potrzebujesz, to przekształcić wyliczenie w ReadonlyCollection i powiązać kolekcję z combobox (lub dowolną formantem z włączoną parą klucz-wartość)

Po pierwsze, potrzebujesz klasy, która będzie zawierała pozycje z listy. Ponieważ wszystko, czego potrzebujesz, to para int / string, sugeruję użycie interfejsu i kombinacji klasy bazowej, abyś mógł zaimplementować funkcjonalność w dowolnym obiekcie:

public interface IValueDescritionItem
{
    int Value { get; set;}
    string Description { get; set;}
}

public class MyItem : IValueDescritionItem
{
    HowNice _howNice;
    string _description;

    public MyItem()
    {

    }

    public MyItem(HowNice howNice, string howNice_descr)
    {
        _howNice = howNice;
        _description = howNice_descr;
    }

    public HowNice Niceness { get { return _howNice; } }
    public String NicenessDescription { get { return _description; } }


    #region IValueDescritionItem Members

    int IValueDescritionItem.Value
    {
        get { return (int)_howNice; }
        set { _howNice = (HowNice)value; }
    }

    string IValueDescritionItem.Description
    {
        get { return _description; }
        set { _description = value; }
    }

    #endregion
}

Oto interfejs i przykładowa klasa, która go implementuje. Zauważ, że klasa Key jest silnie wpisana do Enum i że właściwości IValueDescritionItem są jawnie zaimplementowane (więc klasa może mieć dowolne właściwości i możesz WYBRAĆ te, które implementują Para klucz / wartość.

Teraz klasa EnumToReadOnlyCollection:

public class EnumToReadOnlyCollection<T,TEnum> : ReadOnlyCollection<T> where T: IValueDescritionItem,new() where TEnum : struct
{
    Type _type;

    public EnumToReadOnlyCollection() : base(new List<T>())
    {
        _type = typeof(TEnum);
        if (_type.IsEnum)
        {
            FieldInfo[] fields = _type.GetFields();

            foreach (FieldInfo enum_item in fields)
            {
                if (!enum_item.IsSpecialName)
                {
                    T item = new T();
                    item.Value = (int)enum_item.GetValue(null);
                    item.Description = ((ItemDescription)enum_item.GetCustomAttributes(false)[0]).Description;
                    //above line should be replaced with proper code that gets the description attribute
                    Items.Add(item);
                }
            }
        }
        else
            throw new Exception("Only enum types are supported.");
    }

    public T this[TEnum key]
    {
        get 
        {
            return Items[Convert.ToInt32(key)];
        }
    }

}

Wszystko, czego potrzebujesz w swoim kodzie, to:

private EnumToReadOnlyCollection<MyItem, HowNice> enumcol;
enumcol = new EnumToReadOnlyCollection<MyItem, HowNice>();
comboBox1.ValueMember = "Niceness";
comboBox1.DisplayMember = "NicenessDescription";
comboBox1.DataSource = enumcol;

Pamiętaj, że Twoja kolekcja jest wpisywana za pomocą MyItem, więc wartość combobox powinna zwracać wartość wyliczenia, jeśli powiążesz się z odpowiednią właściwością.

Dodałem właściwość T this [Enum t], aby kolekcja była jeszcze bardziej użyteczna niż zwykłe materiały eksploatacyjne combo, na przykład textBox1.Text = enumcol [HowNice.ReallyNice] .NicenessDescription;

Możesz oczywiście zdecydować się zmienić MyItem w klasę Key / Value używaną tylko do tego puprose, skutecznie pomijając MyItem w argumentach typu EnumToReadnlyCollection, ale wtedy będziesz zmuszony przejść z int dla klucza (co oznacza uzyskanie combobox1. zwróci int, a nie typ wyliczenia). Możesz obejść ten problem, jeśli utworzysz klasę KeyValueItem, aby zastąpić MyItem i tak dalej, i tak dalej ...

Przepraszamy, że włączyłem ten stary wątek.

Poszedłbym w następujący sposób, aby zlokalizować wyliczenie, ponieważ może wyświetlać znaczące i zlokalizowane wartości dla użytkownika, a nie tylko opis, za pośrednictwem pola tekstowego listy rozwijanej w tym przykładzie.

Najpierw tworzę prostą metodę o nazwie OwToStringByCulture, aby pobrać zlokalizowane ciągi znaków z pliku zasobów globalnych, w tym przykładzie jest to BiBongNet.resx w folderze App_GlobalResources. W tym pliku zasobów upewnij się, że wszystkie ciągi są takie same, jak wartości wyliczenia (ReallyNice, SortOfNice, NotNice). W tej metodzie przekazuję parametr: resourceClassName, który jest zwykle nazwą pliku zasobów.

Następnie tworzę statyczną metodę wypełniania listy rozwijanej wyliczeniem jako źródłem danych o nazwie OwFillDataWithEnum. Tej metody można później użyć z dowolnym wyliczeniem.

Następnie na stronie z listą rozwijaną o nazwie DropDownList1 ustawiłem w Page_Load następujący tylko jeden prosty wiersz kodu, aby wypełnić wyliczenie na liście rozwijanej.

 BiBongNet.OwFillDataWithEnum<HowNice>(DropDownList1, "BiBongNet");

Otóż ​​to. Myślę, że za pomocą kilku prostych metod, takich jak te, można wypełnić dowolną kontrolkę listy dowolnym wyliczeniem, nie tylko wartościami opisowymi, ale zlokalizowanym tekstem do wyświetlenia. Możesz uczynić wszystkie te metody jako metody rozszerzające w celu lepszego wykorzystania.

Mam nadzieję, że to pomoże. Udostępnij, aby się podzielić!

Oto metody:

public class BiBongNet
{

        enum HowNice
        {
            ReallyNice,
            SortOfNice,
            NotNice
        }

        /// <summary>
        /// This method is for filling a listcontrol,
        /// such as dropdownlist, listbox... 
        /// with an enum as the datasource.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ctrl"></param>
        /// <param name="resourceClassName"></param>
        public static void OwFillDataWithEnum<T>(ListControl ctrl, string resourceClassName)
        {
            var owType = typeof(T);
            var values = Enum.GetValues(owType);
            for (var i = 0; i < values.Length; i++)
            {
                //Localize this for displaying listcontrol's text field.
                var text = OwToStringByCulture(resourceClassName, Enum.Parse(owType, values.GetValue(i).ToString()).ToString());
                //This is for listcontrol's value field
                var key = (Enum.Parse(owType, values.GetValue(i).ToString()));
                //add values of enum to listcontrol.
                ctrl.Items.Add(new ListItem(text, key.ToString()));
            }
        }

        /// <summary>
        /// Get localized strings.
        /// </summary>
        /// <param name="resourceClassName"></param>
        /// <param name="resourceKey"></param>
        /// <returns></returns>
        public static string OwToStringByCulture(string resourceClassName, string resourceKey)
        {
                return (string)HttpContext.GetGlobalResourceObject(resourceClassName, resourceKey);
        }
}

Enum HowNice {
  [Description("Really Nice")]
  ReallyNice,
  [Description("Kinda Nice")]
  SortOfNice,
  [Description("Not Nice At All")]
  NotNice
}

Aby rozwiązać ten problem, powinieneś użyć metody rozszerzenia i tablicy ciągów, takich jak:

Enum HowNice {
  ReallyNice  = 0,
  SortOfNice  = 1,
  NotNice     = 2
}

internal static class HowNiceIsThis
{
 const String[] strings = { "Really Nice", "Kinda Nice", "Not Nice At All" }

 public static String DecodeToString(this HowNice howNice)
 {
   return strings[(int)howNice];
 }
}

Prosty kod i szybkie dekodowanie.

Wypróbowałem to podejście i zadziałało.

Utworzyłem klasę opakowującą dla wyliczeń i przeładowałem niejawny operator, aby móc przypisać go do zmiennych wyliczeniowych (w moim przypadku musiałem powiązać obiekt z ComboBoxwartością).

Możesz użyć odbicia, aby sformatować wartości wyliczenia w sposób, w jaki chcesz, w moim przypadku pobieram DisplayAttributewartości wyjściowe z wartości wyliczeniowych (jeśli istnieją).

Mam nadzieję że to pomoże.

public sealed class EnumItem<T>
{
    T value;

    public override string ToString()
    {
        return Display;
    }

    public string Display { get; private set; }
    public T Value { get; set; }

    public EnumItem(T val)
    {
        value = val;
        Type en = val.GetType();
        MemberInfo res = en.GetMember(val.ToString())?.FirstOrDefault();
        DisplayAttribute display = res.GetCustomAttribute<DisplayAttribute>();
        Display = display != null ? String.Format(display.Name, val) : val.ToString();
    }

    public static implicit operator T(EnumItem<T> val)
    {
        return val.Value;
    }

    public static implicit operator EnumItem<T>(T val)
    {
        return new EnumItem<T>(val);
    }
}

EDYTOWAĆ:

Tylko w przypadku, używam następujących funkcji w celu uzyskania enumwartości, które używam dla DataSourcezComboBox

public static class Utils
{
    public static IEnumerable<EnumItem<T>> GetEnumValues<T>()
    {
        List<EnumItem<T>> result = new List<EnumItem<T>>();
        foreach (T item in Enum.GetValues(typeof(T)))
        {
            result.Add(item);
        }
        return result;
    }
}

Gdy już masz GetDescriptionmetodę (musi być globalna statyczna), możesz użyć jej za pomocą metody rozszerzającej:

public static string ToString(this HowNice self)
{
    return GetDescription<HowNice>(self);
}

Enum HowNice {   
[StringValue("Really Nice")]   
ReallyNice,   
[StringValue("Kinda Nice")]   
SortOfNice,   
[StringValue("Not Nice At All")]   
NotNice 
}

Status = ReallyNice.GetDescription()

Możesz zdefiniować Enum jako

Enum HowNice {   
[StringValue("Really Nice")]   
ReallyNice,   
[StringValue("Kinda Nice")]   
SortOfNice,   
[StringValue("Not Nice At All")]   
NotNice 
} 

a następnie użyj HowNice.GetStringValue().