java 枚举类型 Enum（Java枚举类型enum用法）

25-02-05 17

如果您想了解java枚举类型Enum的相关知识，那么本文是一篇不可错过的文章，我们将对Java枚举类型enum用法进行全面详尽的解释，并且为您提供关于10|JAVA枚举类enum、C#枚举类型enum

如果您想了解java 枚举类型 Enum的相关知识，那么本文是一篇不可错过的文章，我们将对Java枚举类型enum用法进行全面详尽的解释，并且为您提供关于10 | JAVA枚举类enum、C# 枚举类型 enum、C#enum枚举类型、C#中的枚举类型(Enum)介绍的有价值的信息。

本文目录一览：

java 枚举类型 Enum（Java枚举类型enum用法）
10 | JAVA枚举类enum
C# 枚举类型 enum
C#enum枚举类型
C#中的枚举类型(Enum)介绍

java 枚举类型 Enum（Java枚举类型enum用法）

　　在现实社会中，有些类的实例对象是固定的。例如季节，只有春夏秋冬。如果你创建了一个season类，你当然有义务维护这个类的实例对象只能是春（SPRING）、夏（SUMMER）、秋（AUTUMN）、冬（WINTER）这四个。这个时候就体现出枚举类的作用了，java中枚举类型就是针对这样的场景需求所设计的。

/**
 * 枚举类的后缀建议为Enum，枚举类型的实例对象建议全大写（这样做符合JAVA的规范）
 */
public enum SeasonEnum{  
  SPRING,SUMMER,AUTUMN,WINTER
}

　让我们来看看怎么使用SeasonEnum这个枚举类。

public class Test{
   public static void main(String[] args) {
    String summer = SUMMER;
    //通过valueOf，获取SUMMER的枚举类型
    SeasonEnum season2 = SeasonEnum.valueOf(summer); 
    //直接初始化
    SeasonEnum season1 = SeasonEnum.SPRING; 
    switch (season1) {  
            case SPRING:  
                 System.out.println(“春天”); 
                 break;  
            case SUMMER:  
                 System.out.println(“夏天”); 
                 break;  
            case AUTUMN:  
                 System.out.println(“秋天”); 
                 break; 
            case WINTER:  
                 System.out.println(“冬天”); 
                 break; 
        }  
    }  
}

　　创建SeasonEnum枚举类，在使用的时候利用switch语句进行匹配从而得到相应的输出值，这种做法很常见。如果只需要实现这样的功能，定义一个常量类也可以实现。那么就让我们更进一步来看看枚举类的作用，针对上面的例子，如果我们在很多场景下都要通过SeasonEnum的实例对象获取相对应的中文，每次都使用switch语句就显得代码冗余。我们这样设想一下，当我们创建SeasonEnum这个枚举类时，可不可以让SeasonEnum中的每一个实例对象都有一个getChinese()方法呢。答案是肯定的，而且这种做法在企业开发中很常见。

public enum SeasonEnum {
    //枚举类的实例对象必须在最前面先定义，而且必须每个实例对象都必须维护上chinese成员变量
    SPRING("春天"),SUMMER("夏天"),AUMUTN("秋天"),WINTER("冬天");
 
    private String chinese;
 
    //枚举类型的构造函数默认为private，因为枚举类型的初始化要在当前枚举类中完成。
    SeasonEnum (String chinese){
        this.chinese= chinese;
    }
 
    public String getChinese(){
        return chinese;
    }
}

　　这样乍一看是不是有点像我们平时创建一般实体类一样。其实枚举类型可以看做我们平时新建.class差不多，只是枚举类限制了此类的实例对象。当然，枚举类可以有自己的成员变量和方法。上面的SeasonEnum 枚举类有了chinese这个成员变量，所以我们在定义实例对象时就要维护这个chinese成员变量。现在再来看看，我们是怎么使用这个枚举类简化我们的代码。

public class Test{
    public static void main(String[] args) {
    //直接初始化
    SeasonEnum season1 = SeasonEnum.SPRING; 
    //调用SeasonEnum枚举类的getChinese()方法获取SPRING的中文值
    System.out.println(season1.getChinese()); 
    
   }  
}

-------------------------------------------------------

枚举

注意：枚举是单例的，单例要保证私有化构造器。

1. 如何自定义枚举类

提供类的属性，声明为 private final
声明为 final 的属性，在构造器中初始化
通过公共方法（get）方法来调用属性
创建枚举类的对象：将类的对象声明 public static final

举例如下：

public class Season {

    //1. 提供类的属性，声明为 private final
    private final String seasonName;
    private final String seasonDesc;
    
    //2. 声明为 final 的属性，在构造器中初始化
    private Season (String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    
    //3. 通过公共的方法来调用属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    
    //4. 创建枚举类的对象：将类的对象声明 public static final
    public static final Season SPRING = new Season("spring", "春暖花开");
    public static final Season SUMMER = new Season("summer", "夏日炎炎");
    public static final Season AUTUMN = new Season("autumn", "秋高气爽");
    public static final Season WINTER = new Season("winter", "白雪皑皑");
    
    @Override
    public String toString() {
        return "Season [seasonName=" + seasonName + ", seasonDesc=" + seasonDesc + "]";
    }

    public void show() {
        System.out.println("这是一个季节");
    }
    
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
        spring.show();
        System.out.println(spring.getSeasonName());
    }
}

2. 如何使用 enum 关键字来定义枚举类

将对象放到最前面，并且不需要定义对象的其他属性。
使用 enum 类来定义枚举类，可以使用下述两种方法来返回值。

values() 方法：返回所有值

valueOf() 方法：返回指定对象的值（要求传入的形参name是枚举类对象的名字）
否则，报 java.lang.IllegalArgumentException 异常

改造一下上述代码：

enum SeasonEnum {
    
    SPRING("spring", "春暖花开"),
    SUMMER("summer", "夏日炎炎"),
    AUTUMN("autumn", "秋高气爽"),
    WINTER("winter", "白雪皑皑");
    
    private final String seasonName;
    private final String seasonDesc;

    private SeasonEnum (String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    
    @Override
    public String toString() {
        return "Season [seasonName=" + seasonName + ", seasonDesc=" + seasonDesc + "]";
    }

    public void show() {
        System.out.println("这是一个季节");
    }
    
    public static void main(String[] args) {
        SeasonEnum spring = SeasonEnum.SPRING;
        System.out.println(spring);
        spring.show();
        System.out.println(spring.getSeasonName());
        
        System.out.println("-------------------");
        
        // 1. values() 方法：返回所有值
        SeasonEnum[] seasons = SeasonEnum.values();
        for (int i = 0; i < seasons.length; i++) {
            System.out.println(seasons[i]);
        }
        
        System.out.println("-------------------");

        // 2. valueOf() 方法：返回指定对象的值（要求传入的形参name是枚举类对象的名字）
        // 否则，报 java.lang.IllegalArgumentException 异常
        String str = "SPRING";
        SeasonEnum sea = SeasonEnum.valueOf(str);
        System.out.println(sea);

    }
}

3. 枚举类实现接口

可以让不同的枚举类的对象调用被重写的抽象方法，执行的效果不同。（相当于让每个对象重写抽象方法）

改造如下：

interface Info {
    void show();
}

enum SeasonEnumTest implements Info {
    SPRING("spring", "春暖花开"){
        public void show() {
            System.out.println("春天在哪里?");
        }
    },
    SUMMER("summer", "夏日炎炎"){
        public void show() {
            System.out.println("夏天在哪里?");
        }
    },
    AUTUMN("autumn", "秋高气爽"){
        public void show() {
            System.out.println("秋天在哪里?");
        }
    },
    WINTER("winter", "白雪皑皑"){
        public void show() {
            System.out.println("冬天在哪里?");
        }
    };
    
    private final String seasonName;
    private final String seasonDesc;

    private SeasonEnumTest(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    
    @Override
    public String toString() {
        return "Season [seasonName=" + seasonName + ", seasonDesc=" + seasonDesc + "]";
    }

    public void show() {
        System.out.println("这是一个季节");
    }
    
    public static void main(String[] args) {
        SeasonEnumTest spring = SeasonEnumTest.SPRING;
        System.out.println(spring);
        spring.show();
        System.out.println(spring.getSeasonName());
        
        System.out.println("-------------------");
        
        // 1. values() 方法：返回所有值
        SeasonEnumTest[] seasons = SeasonEnumTest.values();
        for (int i=0; i<seasons.length;i++) {
            System.out.println(seasons[i]);
        }

        System.out.println("-------------------");
        // 2. valueOf() 方法：返回指定对象的值（要求传入的形参name是枚举类对象的名字）
        // 否则，报 java.lang.IllegalArgumentException 异常
        String str = "WINTER";
        SeasonEnumTest sea = SeasonEnumTest.valueOf(str);
        System.out.println(sea);
        sea.show();
    }
}

出处：https://www.e-learn.cn/content/java/2584441

　　 https://blog.csdn.net/cauchy6317/article/details/82313088

10 | JAVA枚举类enum

枚举类 enum

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day == Weekday.SAT || day == Weekday.SUN) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}

enum Weekday {
    SUN, MON, TUE, WED, THU, FRI, SAT;
}

注意到定义枚举类是通过关键字enum实现的，我们只需依次列出枚举的常量名。

和int定义的常量相比，使用enum定义枚举有如下好处：

首先，enum常量本身带有类型信息，即Weekday.SUN类型是Weekday，编译器会自动检查出类型错误。例如，下面的语句不可能编译通过：.

int day = 1;
if (day == Weekday.SUN) { // Compile error: bad operand types for binary operator '=='
}

enum 的比较

使用enum定义的枚举类是一种引用类型。前面我们讲到，引用类型比较，要使用equals()方法，如果使用==比较，它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用equals()方法，但enum类型可以例外。

这是因为enum类型的每个常量在JVM中只有一个唯一实例，所以可以直接用==比较：

if (day == Weekday.FRI) { // ok!
}
if (day.equals(Weekday.SUN)) { // ok, but more code!
}

通过enum定义的枚举类，和其他的class有什么区别？

答案是没有任何区别。enum定义的类型就是class，只不过它有以下几个特点：

定义的enum类型总是继承自java.lang.Enum，且无法被继承；
只能定义出enum的实例，而无法通过new操作符创建enum的实例；
定义的每个实例都是引用类型的唯一实例；
可以将enum类型用于switch语句。

例如，我们定义的Color枚举类：

public enum Color {
    RED, GREEN, BLUE;
}

编译器编译出的class大概就像这样：

public final class Color extends Enum { // 继承自Enum，标记为final class
    // 每个实例均为全局唯一:
    public static final Color RED = new Color();
    public static final Color GREEN = new Color();
    public static final Color BLUE = new Color();
    // private构造方法，确保外部无法调用new操作符:
    private Color() {}
}

枚举类的方法

因为enum是一个class，每个枚举的值都是class实例，因此，这些实例有一些方法：

name（）

String s = Weekday.SUN.name(); // "SUN"

ordinal()

返回定义的常量的顺序，从0开始计数，例如：

int n = Weekday.MON.ordinal(); // 1

关于可扩展性和健壮性

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}
enum Weekday {
    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6), SUN(0);

    public final int dayValue;

    private Weekday(int dayValue) {
        this.dayValue = dayValue;
    }
}
//这样就无需担心顺序的变化，新增枚举常量时，也需要指定一个int值。

不推荐的代码

String task = Weekday.MON.ordinal() + "/ppt";
savetoFile(task);

覆写toString

默认情况下，对枚举常量调用toString()会返回和name()一样的字符串。但是，toString()可以被覆写，而name()则不行。我们可以给Weekday添加toString()方法：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Today is " + day + ". Work at home!");
        } else {
            System.out.println("Today is " + day + ". Work at office!");
        }
    }
}

enum Weekday {
    MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");

    public final int dayValue;
    private final String chinese;

    private Weekday(int dayValue, String chinese) {
        this.dayValue = dayValue;
        this.chinese = chinese;
    }

    @Override
    public String toString() {
        return this.chinese;
    }
}

注意：判断枚举常量的名字，要始终使用name()方法，绝不能调用toString()！

C# 枚举类型 enum

我个人感觉平日用到的enum应该是非常简单的，无非就是枚举和整数、字符串之间的转换。最近工作发现一些同事居然不太会用这个东东，于是就整理一下。

枚举类型是定义了一组“符号名称/值”配对。枚举类型是强类型的。每个枚举类型都是从system.Enum派生，又从system.ValueType派生，而system.ValueType又从system.Object派生，所以枚举类型是值类型。编译枚举类型时，C#编译器会把每个符号转换成类型的一个常量字段。C#编译器将枚举类型视为基元类型。因为enum是值类型，而所有的值类型都是sealed，所以在扩展方法时都不能进行约束。但是，若要限制参数为值类型，可用struct 约束。因为enum一般用于一个字符串和整数值，如果我们需要关联多个字符串的时候可以使用Description特性，如果枚举彼此需要与或运算，需要借助Flags特性，enum里面定义的字符常量其整数值默认从0开始。

看一下枚举定义：

public enum AwardType
    {
        /// <summary>
        ///1 积分
        /// </summary>
        [Description("积分")]
        Integral = 1,

        /// <summary>
        /// 2 充值卡
        /// </summary>
        [Description("充值卡")]
        RechargeCard = 2,

        /// <summary>
        /// 3 实物奖品
        /// </summary>
        [Description("实物奖品")]
        Gift = 3,
    }
    public static class Extend
    {
        public static string Description<T>(this T instance) where T : struct
        {
            string str = string.Empty;
            Type type = typeof(T);
            if (!typeof(T).IsEnum)
            {
                throw new ArgumentException("参数必须是枚举类型");
            }
            var fieldInfo = type.GetField(instance.ToString());
            if (fieldInfo != null)
            {
                var attr = fieldInfo.GetCustomAttribute(typeof(DescriptionAttribute), false) as DescriptionAttribute;
                if (attr != null)
                {
                    str = attr.Description;
                }
                else
                {
                    str = fieldInfo.Name;
                }

            }
            return str;
        }

        public static T GetEnum<T>(this string description)
        {
            var fieldInfos = typeof(T).GetFields();
            foreach (FieldInfo field in fieldInfos)
            {
                DescriptionAttribute attr = field.GetCustomAttribute(typeof(DescriptionAttribute), false) as DescriptionAttribute;
                if (attr != null && attr.Description == description)
                {
                    return (T)field.GetValue(null);
                }
                else if (field.Name == description)
                {
                    return (T)field.GetValue(null);
                }
            }
            throw new ArgumentException(string.Format("{0} 未能找到对应的枚举.", description), "Description");
        }
    }

编译后如下：

在编码的时候必要的注释不能缺少，如下

/// <summary>
/// 3 实物奖品
/// </summary>

这样VS在只能感知的时候就可以看到了。

而枚举的应用也非常简单：

static void Main(string[] args)
        {
            //枚举与整数转换
            int giftInt = (int)AwardType.Gift;
            var a = (AwardType)giftInt;
            //枚举与字符串转换        
            string giftStr = AwardType.Gift.ToString();
            Enum.TryParse(giftStr, out AwardType b);
            ///检测枚举是否有效
            bool isdefine = Enum.IsDefined(typeof(AwardType), 1);
            ////获取枚举描述
            string str = AwardType.Gift.Description();
            ////通过描述获取枚举
            AwardType award = str.GetEnum<AwardType>();
            Console.ReadKey();
        }

这里枚举和其描述信息是直接通过反射来实现的，为了性能提高可以采用字典缓存数据。

C#enum枚举类型

枚举

　　枚举类型声明为一组相关的符号常数定义了一个类型名称。枚举用于“多项选择”场合，就是程序运行时从编译时已经设定的固定数目的“选择”中做出决定。

　　枚举类型（也称为枚举）为定义一组可以赋给变量的命名整数常量提供了一种有效的方法。例如，假设您必须定义一个变量，该变量的值表示一周中的一天。该变量只能存储七个有意义的值。若要定义这些值，可以使用枚举类型。枚举类型是使用 enum 关键字声明的。

enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

默认情况下，枚举中每个元素的基础类型是 int。可以使用冒号指定另一种整数值类型。

如果不为枚举数列表中的元素指定值，则它们的值将以 1 为增量自动递增。在前面的示例中，Days.Sunday 的值为 0，Days.Monday 的值为 1，依此类推。创建新的 Days 对象时，如果不显式为其赋值，则它将具有默认值 Days.Sunday (0)。创建枚举时，应选择最合理的默认值并赋给它一个零值。这便使得只要在创建枚举时未为其显式赋值，则所创建的全部枚举都将具有该默认值。枚举中大小写敏感，但是建议不要这样。

枚举的优点：

<1>枚举可以使代码更易于维护，有助于确保给变量指定合法的、期望的值。

<2>枚举使代码更清晰，允许用描述性的名称表示整数值，而不是用含义模糊的数来表示。

<3>枚举使代码更易于键入。在给枚举类型的实例赋值时，VS.NET IDE会通过IntelliSense弹出一个包含可接受值的列表框，减少了按键次数，并能够让我们回忆起可能的值

枚举实例

　　声明：

public enum TimeOfDay

{

Moning = 0,

Afternoon = 1,

Evening = 2,

};

　　使用：

public string getTimeOfDay(TimeOfDay time)

{

string result = string.Empty;

switch (time)

{

case TimeOfDay.Moning:

result = "上午";

break;

case TimeOfDay.Afternoon:

result = "下午";

break;

case TimeOfDay.Evening:

result = "晚上";

break;

default:

result = "未知";

break;

}

return result;

}

枚举方法

<1>获取枚举字符串

TimeOfDay time = TimeOfDay.Afternoon;

Console.WriteLine(time.ToString());//输出：Afternoon

<2>Enum.Parse()方法。

这个方法带3个参数，第一个参数是要使用的枚举类型。其语法是关键字typeof后跟放在括号中的枚举类名。typeof运算符将在第5章详细论述。第二个参数是要转换的字符串，第三个参数是一个bool，指定在进行转换时是否忽略大小写。最后，注意Enum.Parse()方法实际上返回一个对象引用—— 我们需要把这个字符串显式转换为需要的枚举类型(这是一个取消装箱操作的例子)。对于上面的代码，将返回1，作为一个对象，对应于TimeOfDay.Afternoon的枚举值。在显式转换为int时，会再次生成1。

TimeOfDay time2 = (TimeOfDay) Enum.Parse(typeof(TimeOfDay), "afternoon", true);

Console.WriteLine((int)time2);//输出1

<3>得到枚举的某一值对应的名称

lbOne.Text = Enum.GetName(typeof(TimeOfDay), 0);

<4>得到枚举的所有的值

foreach (int i in Enum.GetValues(typeof(TimeOfDay)))

lbValues.Text += i.ToString();

<5>枚举所有的名称

foreach(string temp in Enum.GetNames(typeof(TimeOfDay)))

lbNames.Text+=temp;

<6>循环输出枚举所有的内容

enum score

{

chinses,

math,

english

}

foreach(var name in Enum.GetNames(typeof(score)))

{

Console.WriteLine("{0}",name);

}

C#中的枚举类型(Enum)介绍

枚举（Enum）定义

enum关键字用于声明枚举，即一种由一组称为枚举数列表的命名常量组成的独特类型。通常情况下，最好是在命名空间内直接定义枚举，以便该命名空间中的所有类都能够同样方便地访问它。但是，还可以将枚举嵌套在类或结构中。现在的有些电商网站根据购物的积分用到的，金牌会员，银牌会员，铜牌会员.

enum MemberLevel
{
    gold,
    silver,
    copper
}

枚举值获取

一般获取的时候包括获取变量和变量值，默认情况下，第一个枚举数的值为 0，后面每个枚举数的值依次递增 1。直接使用Enum中的静态方法即可操作.GetValues中获取的是枚举变量的值，类型是枚举名，之后自动输出的是枚举名.

string s = Enum.GetName(typeof(MemberLevel), 3);
 Console.WriteLine(s);
 
 Console.WriteLine("MemberLevel中的值:");
 foreach (int i in Enum.GetValues(typeof(MemberLevel)))
     Console.WriteLine(i);
 Console.WriteLine("MemberLevel中的值(注意类型):");
 foreach (MemberLevel i in Enum.GetValues(typeof(MemberLevel)))
     Console.WriteLine(i);
 
 Console.WriteLine("MemberLevel中的变量:");
 foreach (string str in Enum.GetNames(typeof(MemberLevel)))
     Console.WriteLine(str);
 System.Console.Read();

枚举类型

曾经很长的一段时间自己一度以为枚举的值只能是int类型，其实每种枚举类型都有基础类型，该类型可以是除 char以外的任何整型(重点)。枚举元素的默认基础类型为 int.准许使用的枚举类型有byte、sbyte、short、ushort、int、uint、long 或 ulong。如果枚举值为long，如下所示:

enum MemberLevel:long
{
    gold = 2147483648L,
    silver=232L,
    copper=10L
}

枚举Flags和Description特性值

可以使用枚举类型定义位标志，从而使该枚举类型的实例可以存储枚举数列表中定义的值的任意组合。创建位标志枚举的方法是应用System.FlagsAttribute特性并适当定义一些值，以便可以对这些值执行AND、OR、NOT和XOR按位运算。一般情况下如果零值不表示“未设置任何标志”，则请不要为标志指定零值.

[Flags]
enum MemberLevel
{
    [Description("二进制表示为1----0001")]
    gold = 0x1,
    [Description("二进制表示为4----0010")]
    silver = 0x04,
    [Description("二进制表示为16----0100")]
    copper = 0x10
}

程序运行如下所示：

// 0001(Gold) and 0100(silver) => 0101(5).
MemberLevel options = MemberLevel.gold | MemberLevel.silver;
Console.WriteLine(options);
Console.WriteLine((int)options);
System.Console.Read();

上面的基本上属于入门的知识，在项目中通常用到的是在枚举变量上面加上Description，需要显示的枚举的特性值，枚举的值一般为int在数据库中占用空间比较小，枚举的变量用于给数据库中的字段赋值，那么如果要显示字段就需要考虑到Descripttion特性，显示中文名称，例如一个用户的的等级在数据中存储的是1，显示的时候显示为金牌用户，当然也可以使用switch，if..else..去判断，如果枚举比较多，自己写的也很不爽.特性这个时候刚发挥作用了，如下所示:

[Description("会员等级")]
enum MemberLevel
{
    [Description("金牌会员")]
    gold =1,
    [Description("银牌会员")]
    silver = 2,
    [Description("铜牌会员")]
    copper =3
}

首先来写一个扩展，静态类，静态方法，this关键字，istop主要是用来获取枚举上面的描述.

public static class EnumHelper
{
    /// <summary>
    /// 返回枚举项的描述信息。
    /// </summary>
    /// <param name="value">要获取描述信息的枚举项。</param>
    /// <returns>枚举想的描述信息。</returns>
    public static string GetDescription(this Enum value, bool isTop = false)
    {
        Type enumType = value.GetType();
        DescriptionAttribute attr = null;
        if (isTop)
        {
            attr = (DescriptionAttribute)Attribute.GetCustomAttribute(enumType, typeof(DescriptionAttribute));
        }
        else
        {
            // 获取枚举常数名称。
            string name = Enum.GetName(enumType, value);
            if (name != null)
            {
                // 获取枚举字段。
                FieldInfo fieldInfo = enumType.GetField(name);
                if (fieldInfo != null)
                {
                    // 获取描述的属性。
                    attr = Attribute.GetCustomAttribute(fieldInfo,typeof(DescriptionAttribute), false) as DescriptionAttribute;
                }
            }
        }
 
        if (attr != null && !string.IsNullOrEmpty(attr.Description))
            return attr.Description;
        else
            return string.Empty;
 
    }
}

主程序调用如下所示：

MemberLevel gold = MemberLevel.gold;
Console.WriteLine(gold.GetDescription());
System.Console.Read();

到此这篇关于C#枚举类型(Enum)的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。

您可能感兴趣的文章:

C# IEnumerator枚举器的具体使用
C#枚举类型与位域枚举Enum
c# EnumHelper枚举常用操作类
深入理解C#中的枚举
C#中可枚举类型详解
理解C#中的枚举（简明易懂）
C#枚举的高级应用
深入理解C#之枚举
简述C#枚举高级战术

我们今天的关于java 枚举类型 Enum和Java枚举类型enum用法的分享就到这里，谢谢您的阅读，如果想了解更多关于10 | JAVA枚举类enum、C# 枚举类型 enum、C#enum枚举类型、C#中的枚举类型(Enum)介绍的相关信息，可以在本站进行搜索。

本文标签：

java 枚举类型 Enum（Java枚举类型enum用法）