blocks|key|341827|text|做到这一点的最好方法是创建一个类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341828|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!");
}|code-block|syntax|javascript|341829|我相信这是最好的方法。|341830|当填充到组合框中时，将显示漂亮的ToString，并且没有人可以创建更多的类实例，这使得它实际上是一个枚举。|341831|附注：可能需要一些轻微的语法修复，我对C#不是很在行。(Java+guy)|341832|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The best way to do this is to make a class.

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

I believe that is the best way to do it.

When stuffed in comboboxes the pretty ToString will be shown, and the fact that no one can make any more instances of your class essentially makes it an enum.

p.s. there may need to be some slight syntax fixes, I'm not super good with C#. (Java guy)

blocks|key|344162|text|无法重写C#中枚举的ToString()。但是，您可以使用扩展方法；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|344163|public+static+string+ToString(this+HowNice+self,+int+neverUsed)
{
++++switch+(self)
++++{
++++++++case+HowNice.ReallyNice:
++++++++++++return+"Rilly,+rilly+nice";
++++++++++++break;
++++...|code-block|syntax|javascript|344164|当然，您必须显式调用该方法，即；|344165|HowNice.ReallyNice.ToString(0)|344166|这不是一个很好的解决方案，只有一个switch语句和所有的东西--但是它应该可以工作，并且希望可以被多次重写……|344167|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Not possible to override the ToString() of enums in C#. However, you can use extension methods;

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

Of course you will have to make an explicit call to the method, i.e;

<pre><code>HowNice.ReallyNice.ToString(0)
</code></pre>

This is not a nice solution, with a switch statement and all - but it should work and hopefully whitout to many rewrites...

blocks|key|3116232|text|鉴于您不希望为每个枚举创建类，我建议创建枚举值/显示文本的字典并将其绑定。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116233|请注意，这依赖于原始post中的GetDescription方法方法。|3116234|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;
}|code-block|syntax|javascript|3116235|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Given that you'd rather not create a class for each enum, I'd recommend creating a dictionary of the enum value/display text and binding that instead.

Note that this has a dependency on the GetDescription method methods in the original post.

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

 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;
}
</code></pre>

blocks|key|344218|text|创建一个包含所需内容的集合(例如，简单的对象包含一个包含HowNice枚举值的Value属性和一个包含GetDescription<HowNice>(Value)的Description属性，并将组合数据绑定到该集合。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|344219|有点像这样：|344220|Combo.DataSource+=+new+EnumeratedValueCollection<HowNice>();
Combo.ValueMember+=+"Value";
Combo.DisplayMember+=+"Description";|code-block|syntax|javascript|344221|当你有一个像这样的集合类时：|344222|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;+}+}
++++}

}|344223|正如您所看到的，可以使用lambda轻松地定制此集合，以选择枚举器的子集和/或实现自定义格式设置为string，而不是使用您提到的GetDescription<T>(x)函数。|344224|entityMap^0|S|7|13|5|1F|U|2A|B|0|0|0|0|0|1D|6|1T|K|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|T|$]]

Create a collection that contains what you need (like simple objects containing a <code>Value</code> property containing the <code>HowNice</code> enum value and a <code>Description</code> property containing <code>GetDescription&lt;HowNice&gt;(Value)</code> and databind the combo to that collection.

Bit like this:

<pre><code>Combo.DataSource = new EnumeratedValueCollection&lt;HowNice&gt;();
Combo.ValueMember = "Value";
Combo.DisplayMember = "Description";
</code></pre>

when you have a collection class like this:

<pre><code>using System;
using System.Linq;
using System.Collections.Generic;
using System.Collections.ObjectModel;

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

 internal static List&lt;EnumeratedValue&lt;T&gt;&gt; ListConstructor()
 {
 return ListConstructor(null, null);
 }

 internal static List&lt;EnumeratedValue&lt;T&gt;&gt; ListConstructor(Func&lt;T, string&gt; format)
 {
 return ListConstructor(null, format);
 }

 internal static List&lt;EnumeratedValue&lt;T&gt;&gt; ListConstructor(Func&lt;T, bool&gt; selection)
 {
 return ListConstructor(selection, null);
 }

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

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

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

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

 [System.Diagnostics.DebuggerDisplay("{Value} ({Description})")]
 public class EnumeratedValue&lt;T&gt;
 {
 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; } }
 }

}
</code></pre>

As you can see, this collection is easily customizable with lambda's to select a subset of your enumerator and/or implement a custom formatting to <code>string</code> instead of using the <code>GetDescription&lt;T&gt;(x)</code> function you mention.

blocks|key|3116307|text|别!枚举是原语，而不是UI对象--从设计的角度来看，让它们为.ToString()中的UI提供服务是非常糟糕的。您在尝试解决错误的问题:真正的问题是您不希望Enum.ToString()出现在组合框中！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116308|现在，这确实是一个非常可以解决的问题！您可以创建一个UI对象来表示组合框项：|3116309|sealed+class+NicenessComboBoxItem
{
++++public+string+Description+{+get+{+return+...;+}+}
++++public+HowNice+Value+{+get;+private+set;+}

++++public+NicenessComboBoxItem(HowNice+howNice)+{+Value+=+howNice;+}
}|code-block|syntax|javascript|3116310|然后，只需将该类的实例添加到组合框的Items集合中，并设置这些属性：|3116311|comboBox.ValueMember+=+"Value";
comboBox.DisplayMember+=+"Description";|3116312|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Don't! Enums are primitives and not UI objects - making them serve the UI in .ToString() would be quite bad from a design standpoint. You are trying to solve the wrong problem here: the real issue is that you do not want Enum.ToString() to show up in the combo box!

Now this is a very solveable problem indeed! You create a UI object to represent your combo box items:

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

 public NicenessComboBoxItem(HowNice howNice) { Value = howNice; }
}
</code></pre>

And then just add instances of this class to your combo box's Items collection and set these properties:

<pre><code>comboBox.ValueMember = "Value";
comboBox.DisplayMember = "Description";
</code></pre>

blocks|key|3116353|text|ComboBox拥有您需要的一切：FormattingEnabled属性，您应该将其设置为true；Format事件，您需要在其中放置所需的格式化逻辑。因此，|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3116354|myComboBox.FormattingEnabled+=+true;
myComboBox.Format+%2B=+delegate(object+sender,+ListControlConvertEventArgs+e)
++++{
++++++++e.Value+=+GetDescription<HowNice>((HowNice)e.Value);
++++}|code-block|syntax|javascript|3116355|entityMap^0|0|8|H|H|19|4|1E|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

<code>ComboBox</code> has everything you need: the <code>FormattingEnabled</code> property, which you should set to <code>true</code>, and <code>Format</code> event, where you'll need to place desired formatting logic. Thus,

<pre><code>myComboBox.FormattingEnabled = true;
myComboBox.Format += delegate(object sender, ListControlConvertEventArgs e)
 {
 e.Value = GetDescription&lt;HowNice&gt;((HowNice)e.Value);
 }
</code></pre>

blocks|key|3116366|text|我认为，如果不简单地绑定到不同的类型，你就不能做到这一点--至少，不是很方便。通常，即使您不能控制ToString()，也可以使用TypeConverter进行自定义格式化-但是System.ComponentModel的东西不支持枚举。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3116367|您可以绑定到描述的string[]，或者本质上类似键/值对的东西？(描述/价值)-类似于：|3116368|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));
++++}
}|code-block|syntax|javascript|3116369|然后绑定到EnumWrapper<HowNice>.GetValues()|3116370|entityMap^0|1D|A|1T|D|2H|L|0|9|8|0|0|5|W|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

I don't think you can do it without simply binding to a different type - at least, not conveniently. Normally, even if you can't control <code>ToString()</code>, you can use a <code>TypeConverter</code> to do custom formatting - but IIRC the <code>System.ComponentModel</code> stuff doesn't respect this for enums.

You could bind to a <code>string[]</code> of the descriptions, or a something essentially like a key/value pair? (desription/value) - something like:

<pre><code>class EnumWrapper&lt;T&gt; 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&lt;T&gt;(value); } }
 public override string ToString() { return Description; }

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

And then bind to <code>EnumWrapper&lt;HowNice&gt;.GetValues()</code>

blocks|key|343410|text|您可以编写一个TypeConverter来读取指定的属性，以便在资源中查找它们。因此，您可以很容易地获得显示名称的多语言支持。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|343411|查看TypeConverter的ConvertFrom/ConvertTo方法，并使用反射读取枚举字段上的属性。|343412|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You could write an TypeConverter that reads specified attributes to look them up in your resources. Thus you would get multi-language support for display names without much hassle.

Look into the TypeConverter's ConvertFrom/ConvertTo methods, and use reflection to read attributes on your enum fields.

blocks|key|3116400|text|我会写一个泛型类，用于任何类型。我以前用过这样的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116401|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
}|code-block|syntax|javascript|3116402|最重要的是，您可以添加一个静态的“工厂方法”来创建给定枚举类型的组合框项的列表(与那里的GetDescriptions方法非常相似)。这将使您不必为每个枚举类型实现一个实体，并且还为"GetDescriptions“帮助器方法提供了一个很好的/逻辑位置(我个人将其称为FromEnum(T+obj)+...|3116403|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I would write a generic class for use with any type. I've used something like this in the past:

<pre><code>public class ComboBoxItem&lt;T&gt;
{
 /// 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
}
</code></pre>

On top of this, you could add a static "factory method" to create a list of combobox items given an enum type (pretty much the same as the GetDescriptions method you have there). This would save you of having to implement one entity per each enum type, and also provide a nice/logical place for the "GetDescriptions" helper method (personally I would call it FromEnum(T obj) ...

blocks|key|3329125|text|您可以创建一个泛型结构，该结构可用于所有具有描述的枚举。通过与类之间的隐式转换，除了ToString方法之外，您的变量仍然像枚举一样工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3329126|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;
++++}

}|code-block|syntax|javascript|3329127|使用示例：|3329128|Described<HowNice>+nice+=+HowNice.ReallyNice;

Console.WriteLine(nice+==+HowNice.ReallyNice);+//+writes+"True"
Console.WriteLine(nice);+//+writes+"Really+Nice"|3329129|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You could make a generic struct that you could use for all of your enums that has descriptions. With implicit conversions to and from the class, your variables still works like the enum except for the ToString method:

<pre><code>public struct Described&lt;T&gt; 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&lt;T&gt;(T value) {
 return new Described&lt;T&gt;(value);
 }

 public static implicit operator T(Described&lt;T&gt; value) {
 return value._value;
 }

}
</code></pre>

Usage example:

<pre><code>Described&lt;HowNice&gt; nice = HowNice.ReallyNice;

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

blocks|key|343440|text|TypeConverter。我想这就是我要找的。万岁，Simon+Svensson！|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|343441|[TypeConverter(typeof(EnumToStringUsingDescription))]
Enum+HowNice+{
++[Description("Really+Nice")]
++ReallyNice,
++[Description("Kinda+Nice")]
++SortOfNice,
++[Description("Not+Nice+At+All")]
++NotNice
}|code-block|syntax|javascript|343442|在我当前的枚举中，我需要做的就是在它们的声明之前添加下面这一行。|343443|[TypeConverter(typeof(EnumToStringUsingDescription))]|343444|一旦我这样做了，任何枚举都将使用其字段的DescriptionAttribute来显示。|style|CODE|343445|哦，TypeConverter的定义是这样的：|343446|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;
++++}
}|343447|这对我的ComboBox用例很有帮助，但显然不会实际覆盖ToString()。我想在此期间我会满足于此...|343448|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/796607/how-do-i-override-tostring-in-c-enums/796675#796675^0|R|E|0|0|0|0|0|K|K|0|2|D|0|0|S|A|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1B|8|@$A|1C|B|1D|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1E|8|@$A|1F|B|1G|O|P]]|9|@]|C|$]]|$1|S|3|T|5|F|7|1H|8|@]|9|@]|C|$G|H]]|$1|U|3|V|5|6|7|1I|8|@$A|1J|B|1K|O|P]]|9|@]|C|$]]|$1|W|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]]]

TypeConverter. I think this is what I was looking for. All hail <a href="https://stackoverflow.com/questions/796607/how-do-i-override-tostring-in-c-enums/796675#796675">Simon Svensson</a>!

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

All I need to change in my current enum is add this line before their declaration.

<pre><code>[TypeConverter(typeof(EnumToStringUsingDescription))]
</code></pre>

Once I do that, any enum will get displayed using the <code>DescriptionAttribute</code> of its fields.

Oh, and the <code>TypeConverter</code> would be defined like this:

<pre><code>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 &gt; 0) ? ((DescriptionAttribute)attrs[0]).Description : name;
 }
}
</code></pre>

This helps me with my ComboBox case, but obviously doesn't actually override the <code>ToString()</code>. I guess I'll settle for this meanwhile...

blocks|key|3116450|text|你可以使用PostSharp来定位Enum.ToString并添加你想要的所有代码。这不需要任何代码更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116451|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You could use PostSharp to target Enum.ToString and add aditionall code you want.
This doesn't require any code changes.

blocks|key|346894|text|您需要做的是将枚举转换为ReadonlyCollection，并将集合绑定到组合框(或任何支持键值对的控件)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|346895|首先，您需要一个类来包含列表中的项。由于您只需要int/string对，因此我建议使用接口和基类组合，这样您就可以在任何想要的对象中实现该功能：|346896|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
}|code-block|syntax|javascript|346897|下面是实现it.Notice的接口和示例类，该类的键被强类型化为枚举，并且IValueDescritionItem属性是显式实现的(因此类可以具有任何属性，您可以选择实现键/值对的属性。|346898|现在是EnumToReadOnlyCollection类：|346899|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)];
++++++++}
++++}

}|346900|因此，您在代码中需要做的就是：|346901|private+EnumToReadOnlyCollection<MyItem,+HowNice>+enumcol;
enumcol+=+new+EnumToReadOnlyCollection<MyItem,+HowNice>();
comboBox1.ValueMember+=+"Niceness";
comboBox1.DisplayMember+=+"NicenessDescription";
comboBox1.DataSource+=+enumcol;|346902|请记住，您的集合是使用MyItem类型化的，因此，如果您绑定到适当的属性，则combobox值应该返回枚举值。|346903|我添加了T+textBox1.Text+t属性，以使集合比简单的组合可用项更有用，例如thisEnum+=TextBox1.Text=+to|346904|当然，您可以选择将MyItem转换为仅用于此过程的键/值类，从而有效地完全跳过EnumToReadnlyCollection的类型参数中的MyItem，但随后您将被迫使用int作为键(这意味着获取combox1.SelectedValue将返回int，而不是枚举类型)。如果创建一个KeyValueItem类来替换MyItem，等等，就可以解决这个问题……|346905|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

What you need is to turn an enum into a ReadonlyCollection and bind the collection to the combobox (or any Key-Value Pair enabled control for that matter)

First off you need a class to contain the items of the list. Since all you need is the int/string pair I suggest using an interface and a base class combo so that you can implement the functionality in any object you want:

<pre><code>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
}
</code></pre>

Here is the interface and a sample class that implements it.Notice that the class' Key is strongly typed to the Enum, and that the IValueDescritionItem proprties are implemented explicitely (so the class can have whatever properties and you can CHOOSE the ones that implement the Key/Value pair.

Now the EnumToReadOnlyCollection class:

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

 public EnumToReadOnlyCollection() : base(new List&lt;T&gt;())
 {
 _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)];
 }
 }

}
</code></pre>

So all you need in your code is :

<pre><code>private EnumToReadOnlyCollection&lt;MyItem, HowNice&gt; enumcol;
enumcol = new EnumToReadOnlyCollection&lt;MyItem, HowNice&gt;();
comboBox1.ValueMember = "Niceness";
comboBox1.DisplayMember = "NicenessDescription";
comboBox1.DataSource = enumcol;
</code></pre>

Remember that your collection is typed with MyItem so the combobox value should return an enum value if you bind to the appropriate proprtie. 

I added the T this[Enum t] property to make the collection even more usefull than a simple combo consumable, for example textBox1.Text = enumcol[HowNice.ReallyNice].NicenessDescription;

You can of course chose to turn MyItem into a Key/Value class used only for this puprose effectively skipping MyItem in the type arguments of EnumToReadnlyCollection altogether, but then you'd be forced to go with int for the key (meaning getting combobox1.SelectedValue would return int and not the enum type). You work around that if you create a KeyValueItem class to replace MyItem and so on and so forth...

blocks|key|344328|text|您可以将枚举定义为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|344329|Enum+HowNice+{+++
[StringValue("Really+Nice")]+++
ReallyNice,+++
[StringValue("Kinda+Nice")]+++
SortOfNice,+++
[StringValue("Not+Nice+At+All")]+++
NotNice+
}+|code-block|syntax|javascript|344330|然后使用HowNice.GetStringValue()。|offset|length|style|CODE|344331|entityMap^0|0|0|4|O|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can define Enum as

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

and then use <code>HowNice.GetStringValue()</code>.

blocks|key|346922|text|一旦你有了GetDescription方法(它需要是全局静态的)，你可以通过一个扩展方法来使用它：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|346923|public+static+string+ToString(this+HowNice+self)
{
++++return+GetDescription<HowNice>(self);
}|code-block|syntax|javascript|346924|entityMap^0|5|E|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Once you have the <code>GetDescription</code> method (it needs to be global static), you could use this through an extension method:

<pre><code>public static string ToString(this HowNice self)
{
 return GetDescription&lt;HowNice&gt;(self);
}
</code></pre>

blocks|key|343504|text|很抱歉把这个老帖子挂起来了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|343505|我将使用以下方法来本地化枚举，因为在本例中，它可以通过下拉列表文本字段向用户显示有意义的本地化值，而不仅仅是描述。|343506|首先，我创建了一个名为OwToStringByCulture的简单方法，用于从全局资源文件中获取本地化字符串，在本例中为App_GlobalResources文件夹中的BiBongNet.resx。在这个资源文件中，确保所有字符串都与枚举的值(ReallyNice、SortOfNice、NotNice)相同。在这个方法中，我传入了参数:+resourceClassName，它通常是资源文件的名称。|343507|接下来，我创建了一个名为OwFillDataWithEnum的静态方法，用枚举作为其数据源来填充下拉列表。此方法稍后可用于任何枚举。|343508|然后在包含一个名为DropDownList1的下拉列表的页面中，我在Page_Load中设置了以下仅一行简单的代码，用于将枚举填充到下拉列表中。|343509|+BiBongNet.OwFillDataWithEnum<HowNice>(DropDownList1,+"BiBongNet");|code-block|syntax|javascript|343510|就这样。我认为使用这些简单的方法，您可以用任何枚举填充任何列表控件，不仅是描述性的值，还包括要显示的本地化文本。您可以将所有这些方法作为扩展方法，以便更好地使用。|343511|希望这能有所帮助。共享以获取共享！|343512|以下是方法：|343513|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%2B%2B)
++++++++++++{
++++++++++++++++//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);
++++++++}
}|343514|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|17|8|@]|9|@]|A|$M|N]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Sorry for getting this old thread up.

I would go the following way to localize enum, as it can display meaningful and localized values to user, not just description, through a dropdownlist text field in this example.

First, I create a simple method called OwToStringByCulture to get localized strings from a global resources file, in this example it is BiBongNet.resx in the App_GlobalResources folder. Inside this resource file, make sure you have all strings the same as the values of the enum (ReallyNice, SortOfNice, NotNice). In this method, I pass in the parameter: resourceClassName which is usually the name of the resource file.

Next, I create a static method to fill a dropdownlist with enum as its datasource, called OwFillDataWithEnum. This method can be used with any enum later.

Then in the page with a dropdownlist called DropDownList1, I set in the Page_Load the following just one simple line of code to fill the enum to the dropdownlist.

<pre><code> BiBongNet.OwFillDataWithEnum&lt;HowNice&gt;(DropDownList1, "BiBongNet");
</code></pre>

That's it. I think with some simple methods like these, you can fill any list control with any enum, with not just as descriptive values but localized text to display. You can make all these methods as extension methods for better use. 

Hope this help.
Share to get shared!

Here are the methods:

<pre><code>public class BiBongNet
{

 enum HowNice
 {
 ReallyNice,
 SortOfNice,
 NotNice
 }

 /// &lt;summary&gt;
 /// This method is for filling a listcontrol,
 /// such as dropdownlist, listbox... 
 /// with an enum as the datasource.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;
 /// &lt;param name="ctrl"&gt;&lt;/param&gt;
 /// &lt;param name="resourceClassName"&gt;&lt;/param&gt;
 public static void OwFillDataWithEnum&lt;T&gt;(ListControl ctrl, string resourceClassName)
 {
 var owType = typeof(T);
 var values = Enum.GetValues(owType);
 for (var i = 0; i &lt; 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()));
 }
 }

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

blocks|key|3116600|text|Enum+HowNice+{+++
[StringValue("Really+Nice")]+++
ReallyNice,+++
[StringValue("Kinda+Nice")]+++
SortOfNice,+++
[StringValue("Not+Nice+At+All")]+++
NotNice+
}

Status+=+ReallyNice.GetDescription()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3116601|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

Status = ReallyNice.GetDescription()
</code></pre>

blocks|key|3116620|text|使用您的枚举示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116621|using+System.ComponentModel;

Enum+HowNice
{
++++[Description("Really+Nice")]
++++ReallyNice,
++++[Description("Kinda+Nice")]
++++SortOfNice,
++++[Description("Not+Nice+At+All")]
++++NotNice
}|code-block|syntax|javascript|3116622|创建一个扩展：|3116623|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;
++++}
}|3116624|然后，您可以使用类似以下内容：|3116625|HowNice+myEnum+=+HowNice.ReallyNice;
string+myDesc+=+myEnum.Description();|3116626|有关详情，请参阅：http://www.blackwasp.co.uk/EnumDescription.aspx。解决方案归功于Richrd+Carr|offset|length|3116627|entityMap|0|LINK|mutability|MUTABLE|url|http://www.blackwasp.co.uk/EnumDescription.aspx^0|0|0|0|0|0|0|9|1B|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@$Q|17|R|18|1|19]]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

Using your enumeration example:

<pre><code>using System.ComponentModel;

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

Create an Extension:

<pre><code>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;
 }
}
</code></pre>

Then you can use something like the following:

<pre><code>HowNice myEnum = HowNice.ReallyNice;
string myDesc = myEnum.Description();
</code></pre>

See: <a href="http://www.blackwasp.co.uk/EnumDescription.aspx" rel="noreferrer">http://www.blackwasp.co.uk/EnumDescription.aspx</a> for more information. Credit goes to Richrd Carr for the solution

blocks|key|343524|text|Enum+HowNice+{
++[Description("Really+Nice")]
++ReallyNice,
++[Description("Kinda+Nice")]
++SortOfNice,
++[Description("Not+Nice+At+All")]
++NotNice
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|343525|要解决此问题，您应该使用扩展方法和字符串数组，如下所示：|unstyled|343526|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];
+}
}|343527|编码简单，解码速度快。|343528|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

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

To resolve this you should use an extension Method and an Array of Strings like so:

<pre><code>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];
 }
}
</code></pre>

Simple code and fast decoding.

blocks|key|3329404|text|在@scraimer之后，这里是枚举到字符串类型转换器的一个版本，它也支持标志：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3329405|++++///+<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;
++++}

}|code-block|syntax|javascript|3329406|以及使用它的扩展方法：|3329407|++++///+<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;
++++}|3329408|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Following up on @scraimer answer, here is a version of the enum-to-string type converter, which supports flags as well:

<pre><code> /// &lt;summary&gt;
/// A drop-in converter that returns the strings from 
/// &lt;see cref="System.ComponentModel.DescriptionAttribute"/&gt;
/// of items in an enumaration when they are converted to a string,
/// like in ToString().
/// &lt;/summary&gt;
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 &gt; 0) ? ((DescriptionAttribute)attrs[0]).Description : name;
 }

 }
 }

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

 /// &lt;summary&gt;
 /// Coverts an Enums to string by it's description. falls back to ToString.
 /// &lt;/summary&gt;
 /// &lt;param name="value"&gt;The value.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public string EnumToString(Enum value)
 {
 //getting the actual values
 List&lt;Enum&gt; values = EnumToStringUsingDescription.GetFlaggedValues(value);
 //values.ToString();
 //Will hold results for each value
 List&lt;string&gt; results = new List&lt;string&gt;();
 //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);

 }

 /// &lt;summary&gt;
 /// 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
 /// &lt;/summary&gt;
 /// &lt;param name="value"&gt;The value.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 private static List&lt;Enum&gt; 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&lt;Enum&gt; values = new List&lt;Enum&gt;();
 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;
 }

}
</code></pre>

And an extension method for using it:

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

blocks|key|344416|text|我尝试了这种方法，它对我很有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|344417|我为枚举创建了一个包装类，并重载了隐式操作符，这样我就可以将它赋给枚举变量(在我的例子中，我必须将一个对象绑定到一个ComboBox值)。|offset|length|style|CODE|344418|您可以使用反射以您想要的方式格式化枚举值，在我的示例中，我从枚举值(如果存在)中检索DisplayAttribute。|344419|希望这能有所帮助。|344420|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);
++++}
}|code-block|syntax|javascript|344421|编辑：|BOLD|344422|以防万一，我使用以下函数来获取用于ComboBox的DataSource的enum值|344423|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;
++++}
}|344424|entityMap^0|0|1M|8|0|16|G|0|0|0|0|3|0|H|8|Q|A|11|4|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@$D|11|E|12|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|17|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|18|8|@$D|19|E|1A|F|S]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1B|8|@$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]]|9|@]|A|$]]|$1|V|3|W|5|N|7|1I|8|@]|9|@]|A|$O|P]]|$1|X|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Y|$]]

I tried this approach and it worked for me.

I created a wrapper class for enums and overloaded the implicit operator so that I can assign it to enum variables (in my case I had to bind an object to a <code>ComboBox</code> value).

You can use reflection to format the enum values the way you want to, in my case I retrieve the <code>DisplayAttribute</code> out of the enum values (if existent).

Hope this helps.

<pre><code>public sealed class EnumItem&lt;T&gt;
{
 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&lt;DisplayAttribute&gt;();
 Display = display != null ? String.Format(display.Name, val) : val.ToString();
 }

 public static implicit operator T(EnumItem&lt;T&gt; val)
 {
 return val.Value;
 }

 public static implicit operator EnumItem&lt;T&gt;(T val)
 {
 return new EnumItem&lt;T&gt;(val);
 }
}
</code></pre>

EDIT:

Just in case, I use the following function to get the <code>enum</code> values that I use for the <code>DataSource</code> of the <code>ComboBox</code>

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

In the post <a href="https://stackoverflow.com/questions/479410/enum-tostring">Enum ToString</a>, a method is described to use the custom attribute <code>DescriptionAttribute</code> like this:

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

And then, you call a function <code>GetDescription</code>, using syntax like:

<pre><code>GetDescription&lt;HowNice&gt;(NotNice); // Returns "Not Nice At All"
</code></pre>

But that doesn't really help me when I want to simply populate a ComboBox with the values of an enum, since I cannot force the ComboBox to call <code>GetDescription</code>.

What I want has the following requirements:

<ul>
<li>Reading <code>(HowNice)myComboBox.selectedItem</code> will return the selected value as the enum value.</li>
<li>The user should see the user-friendly display strings, and not just the name of the enumeration values. So instead of seeing "<code>NotNice</code>", the user would see "<code>Not Nice At All</code>".</li>
<li>Hopefully, the solution will require minimal code changes to existing enumerations.</li>
</ul>

Obviously, I could implement a new class for each enum that I create, and override its <code>ToString()</code>, but that's a lot of work for each enum, and I'd rather avoid that.

Any ideas?

Heck, I'll even throw in a <a href="https://stackoverflow.com/questions/795979/retrieve-a-list-of-the-most-popular-get-param-variations-for-a-given-url">hug</a> as a bounty :-)

How do I have an enum bound combobox with custom string formatting for enum values?

Java

在post 中，描述了使用自定义属性DescriptionAttribute的方法，如下所示：Enum HowNice {  [Description("Really Nice")]  ReallyNice,  [Description("Kinda Nice")]  SortOfNice,  [Description...

问如何让枚举绑定的组合框具有枚举值的自定义字符串格式？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何让枚举绑定的组合框具有枚举值的自定义字符串格式？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何让枚举绑定的组合框具有枚举值的自定义字符串格式？
EN