//Best way so far - Generic TypeConverter with possibility of specific values - suffers from boxing, but hasn't slowed my apps down
using System;
using System.ComponentModel;
 
namespace X
{
    [TypeConverter(typeof(EnumTypeConverter<IPKind>))]
    public enum IPKind
    {
        Static,
        Dhcp,
    }
 
    public class EnumTypeConverter<TEnum> : TypeConverter
    {
        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string) && value is TEnum)
            {
                var e = (TEnum)value;
                return e.DisplayValue(); // culture?
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }
    }
 
    public static class IPKindExtensions
    {
        public static string DisplayValue(this IPKind value)
        {
            // Localization?
            switch (value)
            {
                case IPKind.Static:
                    return "Static";
                case IPKind.Dhcp:
                    return "Dynamic (DHCP)";
                default:
                    return value.ToString();
            }
        }
    }
 
 
 
    public static class EnumExtensions
    {
        public static string DisplayValue<TEnum>(this TEnum value)
        {
            if (value is IPKind)
            {
                return ((IPKind)(object)value).DisplayValue();
            }
            return value.ToString();
        }
    }
}
 
 
// Use:
// Set up combobox to display enum
var enumValues = Enum.GetValues(typeof(WifiSecurity));
 
// Bind to a combo box
w_securityIO.DisplayMember = "Key";
w_securityIO.ValueMember = "Value";
w_securityIO.DataSource = enumValues; // Might throw an ArgumentNullExc which can be ignored - not sure why
 
 
using System;
using System.ComponentModel;
using Hawk.Properties;
 
namespace Hawk
{
    [TypeConverter(typeof(WifiSecurityTypeConverter))]
    public enum WifiSecurity : byte 
    {
        None,
        Wep64,
        Wep128,
        WpaTkip,
        Wpa2Aes,
    }
 
    public class WifiSecurityTypeConverter : TypeConverter
    {
        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            // This code actually works for a DGV (and a combobox)! It's called a lot! (Like, every time a user adjusts the width of a column.)
            if (destinationType == typeof(string) && value is WifiSecurity)
            {
                var e = (WifiSecurity) value;
                return e.DisplayValue(); // culture?
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }
    }
 
    public static class WifiSecurityExtensions
    {
        public static string DisplayValue(this WifiSecurity value)
        {
            // Localization?
            switch (value)
            {
                case WifiSecurity.None:
                    return "None";
                case WifiSecurity.Wep64:
                    return Resources.Wifi_Security_Wep64; // "WEP 64";
                case WifiSecurity.Wep128:
                    return Resources.Wifi_Security_Wep128; // "WEP 128";
                case WifiSecurity.WpaTkip:
                    return Resources.Wifi_Security_WPA; // "WPA/TKIP";
                case WifiSecurity.Wpa2Aes:
                    return Resources.Wifi_Security_WPA2; // "WPA2/AES";
                default:
                    return value.ToString();
            }
        }
    }
}
//End of TypeConverter example
 
public class Wifi
{
    public enum Security
    {
        [Description("WPA2-PSK (AES)")]
        Wpa2,
        [Description("WPA-PSK (TKIP)")]
        Wpa,
        [Description("WEP 64")]
        Wep64,
        [Description("WEP 32")]
        Wep32,
    }
}
 
 
private void InitWifiControls()
{
    var enumValues = Enum.GetValues(typeof (Wifi.Security));
 
    var items = enumValues.Cast<Wifi.Security>().ToDictionary(value => value.GetDescription());
 
    // Bind to a combo box
    w_wifiSecurityIO.DisplayMember = "Key";
    w_wifiSecurityIO.ValueMember = "Value";
    w_wifiSecurityIO.DataSource = new BindingSource(items, null);
}
 
private void InitWifiControls()
{
	var map = new Dictionary<string, Security>() {	
		{"WPA2-PSK (AES)",Wpa2},
		{"WPA-PSK (TKIP)",Wpa},
		{"WEP 64",Wep64},
		{"WEP 32",Wep32},
	};
	w_wifiSecurityIO.DataSource = new BindingSource(modeMap, null);
	w_wifiSecurityIO.DisplayMember = "Key";
	w_wifiSecurityIO.ValueMember = "Value";
}
 
private void GetWifiControlsSelection()
{
	Security selectedSecurity = w_wifiSecurityIO.SelectedValue;
	// w_wifiSecurityIO.SelectedText is blank (don't know why)
	// w_wifiSecurityIO.SelectedItem is the dictionary (but boxed into an object)
}
 
 
public static class Extensions
{
	public static string GetDescription(this Enum value)
	{
	    if (value == null)
	        throw new ArgumentNullException("value");
 
	    FieldInfo fi = value.GetType().GetField(value.ToString());
 
	    var da = (DescriptionAttribute)Attribute.GetCustomAttribute(fi, typeof(DescriptionAttribute));
 
	    string description = da != null ? da.Description : value.ToString();
 
	    return description;
	}
}
 
 
// Third method:
private void InitWifiControls()
{
	var enumValues = Enum.GetValues(typeof(WifiSecurity));
        var items = enumValues.Cast<WifiSecurity>().ToDictionary(value => value.DisplayValue());
	w_wifiSecurityIO.DataSource = new BindingSource(items, null);
	w_wifiSecurityIO.DisplayMember = "Key";
	w_wifiSecurityIO.ValueMember = "Value";
}
 
public enum WifiSecurity : byte 
{
    None,
    Wep64,
    Wep128,
    WpaTkip,
    //Resources.Wifi_Security_WPA
    Wpa2Aes,
}
 
public static class WifiSecurityExtensions
{
    public static string DisplayValue(this WifiSecurity value)
    {
        switch (value)
        {
            case WifiSecurity.None:
                return "None";
            case WifiSecurity.Wep64:
                return "WEP 64";
            case WifiSecurity.Wep128:
                return "WEP 128";
            case WifiSecurity.WpaTkip:
                return "WPA/TKIP";
            case WifiSecurity.Wpa2Aes:
                return "WPA2/AES";
            default:
                throw new ArgumentOutOfRangeException("value");
        }
    }
}