Wie habe ich eine Enum-gebundene Combobox mit benutzerdefinierten String-Formatierung für Enum-Werte?

In der Post Enum ToString wird eine Methode beschrieben, die das benutzerdefinierte Attribut DescriptionAttribute wie folgt verwendet:

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

Und dann rufen Sie eine function GetDescription , die folgende Syntax verwendet:

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

Aber das hilft mir nicht wirklich, wenn ich eine ComboBox einfach mit den Werten einer Aufzählung füllen will, da ich die ComboBox nicht zwingen kann, GetDescription GetDescription .

Was ich will, hat folgende Anforderungen:

  • Reading (HowNice)myComboBox.selectedItem gibt den ausgewählten Wert als Aufzählungswert zurück.
  • Der Benutzer sollte die benutzerfreundlichen Anzeigestrings sehen und nicht nur den Namen der Aufzählungswerte. Anstatt ” NotNice ” zu sehen, würde der Benutzer ” Not Nice At All ” sehen.
  • Hoffentlich erfordert die Lösung nur minimale Codeänderungen an vorhandenen Aufzählungen.

ToString() könnte ich für jede von mir erstellte ToString() eine neue class implementieren und ihre ToString() überschreiben, aber das ist eine Menge Arbeit für jede Enumeration, und das würde ich lieber vermeiden.

Irgendwelche Ideen?

Verdammt, ich werde mich sogar als Kopfgeld umarmen 🙂

Sie könnten einen TypeConverter schreiben, der bestimmte Attribute liest, um sie in Ihren Ressourcen nachzuschlagen. So erhalten Sie ohne viel Aufwand mehrsprachige Unterstützung für Anzeigenamen.

Sehen Sie sich die ConvertFrom / ConvertTo-Methoden des TypeConverters an und verwenden Sie reflection, um Attribute in Ihren enum- Feldern zu lesen.

ComboBox hat alles, was Sie brauchen: die FormattingEnabled Eigenschaft, die Sie auf true , und das Format Event, wo Sie die gewünschte Formatierungslogik platzieren müssen. So,

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

Nicht! Enums sind Primitive und keine UI-Objekte – sie würden dazu dienen, die Benutzeroberfläche in .ToString () zu bedienen. Sie versuchen, das falsche Problem hier zu lösen: Das eigentliche Problem ist, dass Enum.ToString () nicht in der Combo-Box angezeigt werden soll!

Jetzt ist das ein sehr lösbares Problem! Sie erstellen ein UI-Objekt, um Ihre Combobox-Elemente darzustellen:

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

Fügen Sie dann einfach Instanzen dieser class zur Items-Sammlung Ihrer Combobox hinzu und legen Sie diese Eigenschaften fest:

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

TypKonverter. Ich denke, das ist, was ich gesucht habe. Hallo Simon Svensson !

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

Alles, was ich in meiner aktuellen enum ändern muss, ist diese Zeile vor ihrer Deklaration hinzuzufügen.

 [TypeConverter(typeof(EnumToStringUsingDescription))] 

Sobald ich das gemacht habe, wird jedes Enum mit dem DescriptionAttribute seiner Felder angezeigt.

Oh, und der TypeConverter würde folgendermaßen definiert:

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

Dies hilft mir bei meinem ComboBox-Fall, überschreibt aber offensichtlich nicht den ToString() . Ich denke, ich werde mich in der Zwischenzeit damit zufrieden geben …

Verwenden Sie Ihr Aufzählungsbeispiel:

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

Erstellen Sie eine Erweiterung:

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

Dann können Sie etwas wie folgt verwenden:

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

Siehe: http://www.blackwasp.co.uk/EnumDescription.aspx für weitere Informationen. Der Kredit geht an Richrd Carr für die Lösung

Sie könnten eine generische Struktur erstellen, die Sie für alle Ihre enums mit Beschreibungen verwenden können. Bei impliziten Konvertierungen zu und von der class funktionieren Ihre Variablen immer noch wie die Enumeration mit Ausnahme der ToString-Methode:

 public struct Described 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 value) { return new Described(value); } public static implicit operator T(Described value) { return value._value; } } 

Verwendungsbeispiel:

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

Ich glaube nicht, dass Sie es schaffen können, ohne einfach an einen anderen Typ zu binden – zumindest nicht bequem. Normalerweise können Sie, auch wenn Sie ToString() nicht steuern können, einen TypeConverter , um benutzerdefinierte Formatierungen durchzuführen – aber IIRC, das System.ComponentModel stuff respektiert dies nicht für Aufzählungen.

Sie könnten an eine string[] der Beschreibungen oder an etwas, das im Wesentlichen einem Schlüssel / Wert-Paar entspricht, binden? (Beschreibung / Wert) – etwas wie:

 class EnumWrapper 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(value); } } public override string ToString() { return Description; } public static EnumWrapper[] GetValues() { T[] vals = (T[])Enum.GetValues(typeof(T)); return Array.ConvertAll(vals, v => new EnumWrapper(v)); } } 

Und dann an EnumWrapper.GetValues() binden EnumWrapper.GetValues()

Der beste Weg, dies zu tun, ist eine class zu machen.

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

Ich glaube, das ist der beste Weg, dies zu tun.

Wenn sie in Comboboxen gestopft werden, wird der hübsche ToString angezeigt, und die Tatsache, dass niemand mehr Instanzen Ihrer class erstellen kann, macht sie im Grunde zu einer Aufzählung.

ps da muss vielleicht ein paar leichte Syntaxkorrekturen, ich bin nicht super gut mit C #. (Java-Typ)

Da Sie keine class für jede Enumeration erstellen möchten, empfehle ich stattdessen, stattdessen ein Wörterbuch mit dem Enumerationswert / Anzeigetext und der Bindung zu erstellen.

Beachten Sie, dass dies eine Abhängigkeit von den GetDescription-Methodenmethoden im ursprünglichen Post gibt.

 public static IDictionary GetDescriptions() where T : struct { IDictionary values = new Dictionary(); 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; } 

Nicht möglich, die ToString () von Aufzählungen in C # zu überschreiben. Sie können jedoch Erweiterungsmethoden verwenden.

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

Natürlich müssen Sie die Methode explizit aufrufen, dh;

 HowNice.ReallyNice.ToString(0) 

Das ist keine nette Lösung, mit einer switch-statement und allem – aber es sollte funktionieren und hoffentlich zu vielen Umschreibungen …

Im Anschluss an @ Scraimer Antwort, hier ist eine Version des Enum-to-String-Typ-Konverter, der auch Flags unterstützt:

  ///  /// A drop-in converter that returns the strings from ///  /// of items in an enumaration when they are converted to a string, /// like in ToString(). ///  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); } ///  /// Coverts an Enums to string by it's description. falls back to ToString. ///  /// The value. ///  public string EnumToString(Enum value) { //getting the actual values List values = EnumToStringUsingDescription.GetFlaggedValues(value); //values.ToString(); //Will hold results for each value List results = new List(); //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); } ///  /// 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 ///  /// The value. ///  private static List 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 values = new List(); 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; } } 

Und eine Erweiterungsmethode für die Verwendung:

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

Ich würde eine generische class für jeden Typ schreiben. Ich habe so etwas in der Vergangenheit benutzt:

 public class ComboBoxItem { /// 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 } 

Darüber hinaus können Sie eine statische “Factory-Methode” hinzufügen, um eine Liste von Combobox-Elementen mit einem Aufzählungstyp zu erstellen (so ziemlich wie die GetDescriptions-Methode, die Sie dort haben). Dies würde es ersparen, eine Entität pro Enum-Typ zu implementieren und auch einen schönen / logischen Platz für die Hilfsmethode “GetDescriptions” bereitzustellen (persönlich würde ich es FromEnum (T obj) nennen …)

Erstellen Sie eine Sammlung, die das enthält, was Sie benötigen (z. B. einfache Objekte mit einer Value Eigenschaft, die den HowNice Enum-Wert enthält, und eine Description Eigenschaft, die GetDescription(Value) und das Combo an diese Sammlung bindet GetDescription(Value) .

Bit wie folgt:

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

Wenn Sie eine Sammelklasse wie diese haben:

 using System; using System.Linq; using System.Collections.Generic; using System.Collections.ObjectModel; namespace Whatever.Tickles.Your.Fancy { public class EnumeratedValueCollection : ReadOnlyCollection> { public EnumeratedValueCollection() : base(ListConstructor()) { } public EnumeratedValueCollection(Func selection) : base(ListConstructor(selection)) { } public EnumeratedValueCollection(Func format) : base(ListConstructor(format)) { } public EnumeratedValueCollection(Func selection, Func format) : base(ListConstructor(selection, format)) { } internal EnumeratedValueCollection(IList> data) : base(data) { } internal static List> ListConstructor() { return ListConstructor(null, null); } internal static List> ListConstructor(Func format) { return ListConstructor(null, format); } internal static List> ListConstructor(Func selection) { return ListConstructor(selection, null); } internal static List> ListConstructor(Func selection, Func format) { if (null == selection) selection = (x => true); if (null == format) format = (x => GetDescription(x)); var result = new List>(); foreach (T value in System.Enum.GetValues(typeof(T))) { if (selection(value)) { string description = format(value); result.Add(new EnumeratedValue(value, description)); } } return result; } public bool Contains(T value) { return (Items.FirstOrDefault(item => item.Value.Equals(value)) != null); } public EnumeratedValue 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 { 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; } } } } 

Wie Sie sehen können, ist diese Sammlung leicht anpassbar mit lambda, um eine Teilmenge Ihres Enumerators auszuwählen und / oder eine benutzerdefinierte Formatierung in eine string implementieren, anstatt die von Ihnen erwähnte function GetDescription(x) verwenden.

Sie können PostSharp verwenden, um auf Enum.ToString zu zielen und zusätzlichen Code hinzuzufügen, den Sie möchten. Dies erfordert keine Codeänderungen.

Was Sie brauchen, ist ein Enum in eine ReadonlyCollection umzuwandeln und die Sammlung an die Combobox zu binden (oder ein beliebiges Key-Value-Pair-Steuerelement für diese Angelegenheit)

Als erstes brauchen Sie eine class, um die Elemente der Liste zu enthalten. Da Sie nur das int / string-Paar benötigen, das ich empfehle, eine Schnittstelle und eine Basisklassen-Kombination zu verwenden, können Sie die functionalität in jedem beliebigen Objekt implementieren:

 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 } 

Hier ist die Schnittstelle und eine Beispielklasse, die es implementiert. Beachten Sie, dass der Schlüssel der class stark in die Enum eingetippt ist, und dass die IValueDescritionItem – Eigenschaften explizit implementiert sind (also kann die class beliebige Eigenschaften haben und Sie können diejenigen auswählen, die das implementieren) Schlüssel / Wert-Paar

Nun die EnumToReadOnlyCollection-class:

 public class EnumToReadOnlyCollection : ReadOnlyCollection where T: IValueDescritionItem,new() where TEnum : struct { Type _type; public EnumToReadOnlyCollection() : base(new List()) { _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)]; } } } 

Alles, was Sie in Ihrem Code benötigen, ist:

 private EnumToReadOnlyCollection enumcol; enumcol = new EnumToReadOnlyCollection(); comboBox1.ValueMember = "Niceness"; comboBox1.DisplayMember = "NicenessDescription"; comboBox1.DataSource = enumcol; 

Denken Sie daran, dass Ihre Sammlung mit MyItem typisiert ist, so dass der Combobox-Wert einen Enum-Wert zurückgeben sollte, wenn Sie an die entsprechende Eigenschaft binden.

Ich habe die Eigenschaft T this [Enum t] hinzugefügt, um die Sammlung noch nützlicher zu machen als ein einfaches Combo-Verbrauchsmaterial, zum Beispiel textBox1.Text = enumcol [HowNice.ReallyNice] .NicenessDescription;

Sie können natürlich MyItem in eine Key / Value-class verwandeln, die nur für diese puprose verwendet wird und MyItem in den type-Argumenten von EnumToReadnlyCollection vollständig überspringt, aber dann müssten Sie mit int für den Schlüssel gehen (also combobox1.SelectedValue erhalten) würde int und nicht den Enum-Typ zurückgeben). Sie umgehen das, wenn Sie eine KeyValueItem-class erstellen, um MyItem zu ersetzen und so weiter und so fort …

Entschuldigung dafür, dass du diesen alten Thread aufgegriffen hast.

Ich würde den folgenden Weg gehen, Enumeration zu lokalisieren, wie es sinnvolle und lokalisierte Werte für Benutzer, nicht nur Beschreibung, durch ein Dropdown-Listenfeld in diesem Beispiel anzeigen kann.

Zuerst erstelle ich eine einfache Methode namens OwToStringByCulture, um lokalisierte Strings aus einer globalen Ressourcendatei zu erhalten, in diesem Beispiel ist es BiBongNet.resx im Ordner App_GlobalResources. Stellen Sie in dieser Ressourcendatei sicher, dass alle Zeichenfolgen den Werten der Enumeration entsprechen (ReallyNice, SortOfNice, NotNice). Bei dieser Methode gebe ich den Parameter: resourceClassName ein, der normalerweise der Name der Ressourcendatei ist.

Als Nächstes erstelle ich eine statische Methode, um eine Dropdown-Liste mit Enum als Datenquelle, genannt OwFillDataWithEnum, zu füllen. Diese Methode kann später mit jeder Enumeration verwendet werden.

Auf der Seite mit der Dropdown-Liste DropDownList1 setze ich in Page_Load die folgende einfache Codezeile, um die Enumeration in die Dropdown-Liste einzufügen.

  BiBongNet.OwFillDataWithEnum(DropDownList1, "BiBongNet"); 

Das ist es. Ich denke, mit einigen einfachen Methoden wie diesen können Sie jedes Listensteuerelement mit beliebigen Aufzählungszeichen füllen, und zwar nicht nur als beschreibende Werte, sondern auch als lokalisierten Text. Sie können alle diese Methoden als Erweiterungsmethoden für eine bessere Verwendung machen.

Ich hoffe das hilft. Teilen, um geteilt zu werden!

Hier sind die Methoden:

 public class BiBongNet { enum HowNice { ReallyNice, SortOfNice, NotNice } ///  /// This method is for filling a listcontrol, /// such as dropdownlist, listbox... /// with an enum as the datasource. ///  ///  ///  ///  public static void OwFillDataWithEnum(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())); } } ///  /// Get localized strings. ///  ///  ///  ///  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 } 

Um dies zu beheben, sollten Sie eine Erweiterungsmethode und ein Array von Strings wie folgt verwenden:

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

Einfacher Code und schnelle Decodierung.

Ich habe diesen Ansatz versucht und es hat für mich funktioniert.

Ich habe eine Wrapper-class für Enums erstellt und den impliziten Operator überladen, so dass ich ihn enum-Variablen zuweisen kann (in meinem Fall musste ich ein Objekt an einen ComboBox Wert binden).

Sie können reflection verwenden, um die enum-Werte so zu formatieren, wie Sie möchten. In meinem Fall DisplayAttribute ich das DisplayAttribute aus den enum-Werten (falls vorhanden).

Hoffe das hilft.

 public sealed class EnumItem { 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(); Display = display != null ? String.Format(display.Name, val) : val.ToString(); } public static implicit operator T(EnumItem val) { return val.Value; } public static implicit operator EnumItem(T val) { return new EnumItem(val); } } 

BEARBEITEN:

Nur für den Fall verwende ich die folgende function, um die enum Werte zu erhalten, die ich für die DataSource der ComboBox

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

Sobald Sie die GetDescription Methode verwenden (sie muss global static sein), können Sie dies über eine Erweiterungsmethode verwenden:

 public static string ToString(this HowNice self) { return GetDescription(self); } 
 Enum HowNice { [StringValue("Really Nice")] ReallyNice, [StringValue("Kinda Nice")] SortOfNice, [StringValue("Not Nice At All")] NotNice } Status = ReallyNice.GetDescription() 

Sie können Enum als definieren

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

und dann HowNice.GetStringValue() .