C#枚举（enum）、常量（const）和readonly

const修饰的是（类）静态常量，，其值是在编译期间确定的readonly修饰的是动态常量。

A、C#中的const和readonly的区别

     C#中定义常量有两种方式，一种叫做静态常量，使用“const”关键字定义（即const = static const），const定义的值是在编译期间确定的，只能在声明时通过常量表达式指定其值。另一种叫做动态常量，用“readonly”关键字来定义。两者区别如下：

1. const只能修饰基元类型、枚举类型或字符串类型，即限制const类型必须属于值类型范围，且其值不能通过new来进行设置，readonly没有限制；
2. const可用于修饰class的field或者一个局部变量（local variable）；而readonly仅仅用于修饰class的field；
3. const常量属于类级别而不是实例对象级别，readonly常量既可以是类级别也可以是实例对象级别的；
4. const常量的效率更高并且不占用内存空间。const常量经过编译器编译后，在代码中引用const变量的地方会用const变量所对应的实际值来代替。而readonly常量需要系统为其所定义的常量分配空间。

B、C#枚举和常量的应用区别浅析，原文地址：http://developer.51cto.com/art/200908/144474.htm

C# 枚举和常量应用区别是什么呢？

当我们需要定义的时候呢，优先考虑枚举。

在C#中，枚举的真正强大之处是它们在后台会实例化为派生于基类System.Enum的结构。这表示可以对它们调用方法，执行有用的任务。注意因为.NET Framework的执行方式，在语法上把枚举当做结构是不会有性能损失的。实际上，一旦代码编译好，枚举就成为基本类型，与int和float类似。

但是在实际应用中，你也许会发现，我们经常用英语定义枚举类型，因为开发工具本来就是英文开发的，美国人用起来，就直接能够明白枚举类型的含义。其实，我们在开发的时候就多了一步操作，需要对枚举类型进行翻译。没办法，谁让编程语言是英语写的，如果是汉语写的，那我们也就不用翻译了，用起枚举变得很方便了。举个简单的例子，TimeOfDay.Morning一看到Morning，美国人就知道是上午，但是对于中国的使用者来说，可能有很多人就看不懂，这就需要我们进行翻译、解释，就向上面的getTimeOfDay()的方法，其实就是做了翻译工作。所以，在使用枚举的时候，感觉到并不是很方便，有的时候我们还是比较乐意创建常量，然后在类中，声明一个集合来容纳常量和其意义。

C# 枚举和常量之使用常量定义：这种方法固然可行，但是不能保证传入的参数day就是实际限定的。

1. using System;  
2. using System.Collections.Generic;  
3.  //C# 枚举和常量应用区别
4. public class TimesOfDay  
5. {  
6. public const int Morning = 0;  
7. public const int Afternoon = 1;  
8. public const int Evening = 2;  
9. public static Dictionary﹤int, string﹥ list;  
10. /// ﹤summary﹥  
11. /// 获得星期几  
12. /// ﹤/summary﹥  
13. /// ﹤param name="day"﹥﹤/param﹥  
14. /// ﹤returns﹥﹤/returns﹥  
15. public static string getTimeNameOfDay(int time)  
16. {  
17. if (list == null || list.Count ﹤= 0)  
18. {  
19. list = new Dictionary﹤int, string﹥();  
20. list.Add(Morning, "上午");  
21. list.Add(Afternoon, "下午");  
22. list.Add(Evening, "晚上");  
23. }  
24.  
25. return list[time];  
26. }  
27. } 

希望能够找到一种比较好的方法，将枚举转为我们想要的集合。搜寻了半天终于找到了一些线索。通过反射，得到针对某一枚举类型的描述。

C# 枚举和常量应用区别之枚举的定义中加入描述

1. using System;  
2. using System.ComponentModel;  
3.  //C# 枚举和常量应用区别
4. public enum TimeOfDay  
5. {  
6. [Description("上午")]  
7. Moning,  
8. [Description("下午")]  
9. Afternoon,  
10. [Description("晚上")]  
11. Evening,  
12. }; 

C# 枚举和常量应用区别之获得值和表述的键值对

1. /// ﹤summary﹥  
2. /// 从枚举类型和它的特性读出并返回一个键值对  
3. /// ﹤/summary﹥  
4. /// ﹤param name="enumType"﹥  
5. Type,该参数的格式为typeof(需要读的枚举类型)  
6. ﹤/param﹥  
7. /// ﹤returns﹥键值对﹤/returns﹥  
8. public static NameValueCollection   
9. GetNVCFromEnumValue(Type enumType)  
10. {  
11. NameValueCollection nvc = new NameValueCollection();  
12. Type typeDescription = typeof(DescriptionAttribute);  
13. System.Reflection.FieldInfo[]   
14. fields = enumType.GetFields();  
15. string strText = string.Empty;  
16. string strValue = string.Empty;  
17. foreach (FieldInfo field in fields)  
18. {  
19. if (field.FieldType.IsEnum)  
20. {  
21. strValue = ((int)enumType.InvokeMember(  
22. field.Name, BindingFlags.GetField, null,   
23. null, null)).ToString();  
24. object[] arr = field.GetCustomAttributes(  
25. typeDescription, true);  
26. if (arr.Length ﹥ 0)  
27. {  
28. DescriptionAttribute aa =   
29. (DescriptionAttribute)arr[0];  
30. strText = aa.Description;  
31. }  
32. else 
33. {  
34. strText = field.Name;  
35. }  
36. nvc.Add(strText, strValue);  
37. }  
38. }  //C# 枚举和常量应用区别
39. return nvc;  
40. } 

当然，枚举定义的也可以是中文，很简单的解决的上面的问题，但是，我们的代码看起来就不是统一的语言了。

1. ChineseEnum  
2. public enum TimeOfDay  
3. {  
4. 上午,  
5. 下午,  
6. 晚上,  
7. } 

C、C#获取枚举的键名称、值和描述，遍历枚举

C# Enum  枚举的操作。  键名称，值 和描述  和 遍历枚举

 /// <summary>

     /// 促销
     /// </summary>
     public enum cxsd
     {




         [Description("推荐")]
         tj = 2,
         [Description("置顶")]
         zd = 4,
         [Description("热卖")]
         rm = 8

     }

//获取 枚举 值

Array rolearry = Enum.GetValues(typeof(cxsd));

//获取枚举名称

String[]rolearry = Enum.GetNames(typeof(cxsd));

获取枚举描述

descriptions(cxsd.rm);//调用

    public static string description(Enum  en)
        {


            Type type = en.GetType();
            MemberInfo[] memInfo = type.GetMember(en.ToString());
            if (memInfo != null && memInfo.Length > 0)
            {
                object[] attrs = memInfo[0].GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false);
                if (attrs != null && attrs.Length > 0)
                    return ((DescriptionAttribute)attrs[0]).Description;
            }
            return en.ToString();
        }

//遍历枚举

  Type type = typeof(cxsd);


            foreach (FieldInfo x in type.GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                cxsd item = (cxsd)x.GetValue(null);
            }

//通过以上方法 扩展一个 通用方法 。来获取  指定值的 描述信息

//调用方法

List<int> vlist=new List<int>();

vlist.add(4);

vlist.add(8);

descriptions<cxsd>(vlist);

 /// <summary>
       /// 获取描述信息
       /// </summary>
       /// <param name="envalue">枚举值的集合</param>
       /// <returns>枚举值对应的描述集合</returns>
       public static List<String> descriptions<T>(List<int> envalue)
       {


           Type type = typeof(T);


                List<String> deslist = new List<String>();


            foreach (FieldInfo x in type.GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                T item = (T)x.GetValue(null);
                if (envalue.Find((int e) => { return e == Convert.ToInt32(item); }) > 0)
                { 
                    deslist.Add(description<T>(item)); 
                }
            }

            return deslist;
       }


         public static string description<T>(T en)
        {


            Type type = en.GetType();
            MemberInfo[] memInfo = type.GetMember(en.ToString());
            if (memInfo != null && memInfo.Length > 0)
            {
                object[] attrs = memInfo[0].GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false);
                if (attrs != null && attrs.Length > 0)
                    return ((DescriptionAttribute)attrs[0]).Description;
            }
            return en.ToString();
        }