调试易

public enum RelationOpert
  {
  > ,
  < ,
  >=,
  <=
  }什么呀 要求就是让开发者 在使用属性的时候，只能选，而不能随便的输入。

特殊字符，编译都通不过。当然不可能。写到枚举的Description里，用反射取出来还能实现。

其实你用字符串常量类代替枚举更合适。public class RelationOpert
{
   public const string Great = ">";
   public const string Less = "<";
   public const string GreatEqual = ">=";
   ...
}

那就说下完整的需求，这个属性就是为了拼接字符串用的，如果用Great 枚举，在判断的时候也要用if else  if
最关键的是： 我要在控件的属性时候，让其他人员选择，只能从4个中选择，并且在用的时候能直接取到> <等等。

感觉这个较好，
｛
 private void button1_Click(object sender, EventArgs e)
        {
            Type ff = typeof(RelationOpert);
            ..... //怎么写啊，只能取到名字和值，怎么获取描述呢？    
   }
    }
    public enum RelationOpert
    {
        [Description("=")]
        Equal,
        [Description(">")]
        Great,
        Less,
        GreatEqual,
        LessEqual    }

foreach (FieldInfo field in typeof(RelationOpert).GetFields(BindingFlags.Public | BindingFlags.Static))
                    {
                        object[] atts = field.GetCustomAttributes(typeof(DescriptionAttribute), true);
...
}

class Program
{
    static void Main(string[] args)
    {
        var list = GetEnumDescription(typeof(Test));
    }    public static List<KeyValuePair<int, string>> GetEnumDescription(Type enumType)
    {
        var descriptions = new List<KeyValuePair<int, string>>();
        FieldInfo[] fis = enumType.GetFields();
        foreach (var fi in fis)
        {
            if (fi.FieldType == typeof(Int32)) continue;
            DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.
                GetCustomAttributes(typeof(DescriptionAttribute), false);
            int key = (int)fi.GetValue(null);
            string desc = (attributes.Length > 0) ? attributes[0].Description : fi.Name;
            descriptions.Add(new KeyValuePair<int, string>(key, desc));
        }
        return descriptions;
    }
}public enum Test
{ 
    [Description(">")]
    A,
    B,
    C
}

 string[] str = new string[] { "> ", "< ", ">=", "<=" };

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        this.propertyGrid1.SelectedObject = new My();        TypeConverter convert = new MyEnumConverter(typeof(RelationOp));
        string g = convert.ConvertToInvariantString(RelationOp.Greater);   // >
        string e = convert.ConvertToInvariantString(RelationOp.Less);      // ==
    }    class My
    {
        public string Name { get; set; }
        public RelationOp Op { get; set; }
    }    [TypeConverter(typeof(MyEnumConverter))]  //<---
    enum RelationOp
    {
        [Description(">")]
        Greater,        [Description("<")]
        Less,        [Description("==")]
        Equal,
    }    class MyEnumConverter : EnumConverter
    {
        static Dictionary<Enum, string> DisplayNames = new Dictionary<Enum, string>();
        public MyEnumConverter(Type t) : base(t) 
        {
            if (DisplayNames.Count == 0)
            {
                foreach (FieldInfo fi in this.EnumType.GetFields(BindingFlags.Static | BindingFlags.GetField | BindingFlags.Public))
                {
                    Enum value = (Enum)fi.GetValue(null);
                    string display = value.ToString();
                    foreach(Attribute attr in fi.GetCustomAttributes(false))
                    {
                        if(attr is DescriptionAttribute)
                        {
                            display = (attr as DescriptionAttribute).Description;
                            break;
                        }
                    }
                    DisplayNames.Add(value, display);
                }
            }
        }
        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            if (value is string)
            {
                foreach (Enum key in DisplayNames.Keys)
                {
                    if (string.CompareOrdinal(DisplayNames[key], value as string) == 0) return key;
                }
            }
            return base.ConvertFrom(context, culture, value);
        }
        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string) && value is Enum)
            {
                if (DisplayNames.ContainsKey((Enum)value)) return DisplayNames[(Enum)value];
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }
    }
}

这个MyEnumConverter不能修饰多个枚举。需要更正：
1、可以改为MyEnumConverter<T>
2、或者把字典改为非静态（去掉statis）：static Dictionary<Enum, string> DisplayNames...

高手都来了，，非常的感谢，我试了上面两种的。也都能实现我的要求我最后用的是 还是有点不同，因为这样的更方便。
 public static string GetEnumDescription(object enumSubitem)
        {
            enumSubitem=(Enum)enumSubitem;
            string strValue = enumSubitem.ToString();            FieldInfo fieldinfo = enumSubitem.GetType().GetField(strValue);            if (fieldinfo != null)
            {                Object[] objs = fieldinfo.GetCustomAttributes(typeof(DescriptionAttribute), false);               if (objs == null || objs.Length == 0)
              {
                    return strValue;
                }
                else
                {
                    DescriptionAttribute da = (DescriptionAttribute)objs[0];
                    return da.Description;
                }
            }
            else
            {
                return "不限";
            }        }
调用非常简单   string type = GetEnumDescription(controlShow1.RelationOpert);

controlShow1  是控件的名字RelationOpert 是枚举类型的属性。
public partial class ControlShow : UserControl
    {
        public ControlShow()
        {
            InitializeComponent();
           
        }          private List<int> item = new List<int>();        public List<int> Item
        {
            get { return item; }
            set { item = value; }
        }        RelationType relationOpert = RelationType.Equal;        public RelationType RelationOpert
        {
            get { return relationOpert; }
            set { relationOpert = value; }
        }    }
    public enum RelationType
    {
        [Description("=")]
        Equal,
        [Description(">")]
        Great,
        [Description("<")]
        Less,
        [Description(">=")]
        GreatEqual,
        [Description("<=")]
        LessEqual    }