C# 枚举---分析与理解

在这篇文章中，我们会以示例的形式讨论枚举（Enums）。在文章末尾，你会懂得枚举是什么，什么时候使用枚举，如何使用枚举。

为什么我们需要枚举？

枚举是强类型的名称常量。我们用示例理解一下枚举。一个名为Employee类，Gender属性。Gender是整型。

1、0是未知性别；

2、1是男性；

3、2是女性；

using System;
using System.Collections.Generic;

namespace EnumsDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Create a collection to store employees
            List<Employee> empList = new List<Employee>();
            empList.Add(new Employee() { Name = "Anurag", Gender = 0});
            empList.Add(new Employee() { Name = "Pranaya", Gender = 1 });
            empList.Add(new Employee() { Name = "Priyanka", Gender = 2 });
            empList.Add(new Employee() { Name = "Sambit", Gender = 3 });
            
            //Loop through each employees and print the Name and Gender
            foreach (var emp in empList)
            {
                Console.WriteLine("Name = {0} && Gender = {1}", emp.Name, GetGender(emp.Gender));
            }

            Console.ReadLine();
        }

        //This method is used to return the Gender 
        public static string GetGender(int gender)
        {
            // The switch here is less readable because of these integral numbers
            switch (gender)
            {
                case 0:
                    return "Unknown";
                case 1:
                    return "Male";
                case 2:
                    return "Female";
                default:
                    return "Invalid Data for Gender";
            }
        }
    }

    // 0 - Unknown
    // 1 - Male
    // 2 - Female
    public class Employee
    {
        public string Name { get; set; }
        public int Gender { get; set; }
    }
}

 

 上述项目代码的缺点是可读性差，可维护性差。现在，我们看一下如何使用枚举进行整体替换，使项目代码具有更好的可读和可维护性。

首先，用枚举创建Gender

 

 修改GetGender函数方法，如下所示：

 

 像上面那样，我们用枚举代替了数字，可以使代码更加可读和可维护。

 

 “Gender.Unknown”会提示错误，无法将Gender.Unknown隐式转换为int。因此，需要强制转换，完整代码如下：

 

using System;
using System.Collections.Generic;

namespace EnumsDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Create a collection to store employees
            List<Employee> empList = new List<Employee>();
            empList.Add(new Employee() { Name = "Anurag", Gender = 0});
            empList.Add(new Employee() { Name = "Pranaya", Gender = 1 });
            empList.Add(new Employee() { Name = "Priyanka", Gender = 2 });
            empList.Add(new Employee() { Name = "Sambit", Gender = 3 });
            
            //Loop through each employees and print the Name and Gender
            foreach (var emp in empList)
            {
                Console.WriteLine("Name = {0} && Gender = {1}", emp.Name, GetGender(emp.Gender));
            }

            Console.ReadLine();
        }

        //This method is used to return the Gender 
        public static string GetGender(int gender)
        {
            // The switch here is now more readable and maintainable because 
            // of replacing the integral numbers with Gender enum
            switch (gender)
            {
                case (int)Gender.Unknown:
                    return "Unknown";
                case (int)Gender.Male:
                    return "Male";
                case (int)Gender.Female:
                    return "Female";
                default:
                    return "Invalid Data for Gender";
            }
        }
    }

    // 0 - Unknown
    // 1 - Male
    // 2 - Female
    public class Employee
    {
        public string Name { get; set; }
        public int Gender { get; set; }
    }

    public enum Gender
    {
        Unknown,
        Male,
        Female
    }
}

 

 所以，如果一个项目用的是一系列数字，可以考虑用枚举代替，这样程序代码会可读和可维护。

需要记住的枚举的几点

1、枚举是enumerations;

2、枚举是强类型的命名常量。因此，显式强制转换是需要将枚举类型转换成整型，反之亦然；同样地，一种类型的枚举不能隐式地赋值给另一种类型的枚举，尽管他们的成员的底层数值是一样的。

3、默认枚举的底层数据类型是int 。

4、枚举的第一个元素默认值为0，以1递增。

5、也可以自定义枚举的底层数据类型和数值。

6、枚举是值类型。

7、Enum关键字用于创建枚举类型，借鉴于Enum class ，枚举包含静态方法GetValues()和GetNames()，这两个函数能用于罗列枚举的底层类型和名称。

Gender枚举底层数据类型是short，数值从1开始，以1递增

 

 

 所以，这样看的话，Male值是2，Female值是3；枚举值不必须是连续的，任何有效的底层数值都是允许的，如下面这样：

 

 

 下面的枚举代码不是进行编译，因为short数据类型的最大值是32767

 

 

 注：可以用short.MaxValue来找出short所能支持的最大数值。

显式转换可以将枚举类型转换为整型，反之亦然

int i = Gender.Male;

上面代码不会编译，编译错误创建如下：Cannot implicitly convert type ‘Gender’ to ‘int’. An explicit conversion exists (are you missing a cast?)

Gender female = 2;

上面代码也不会编译，类似编译错误创建如下：The left-hand side of an assignment must be a variable, property or indexer

一种类型的枚举不能隐式赋值给另一种类型的枚举

尽管底层的数据类型是一样的，但是一种类型的枚举不能赋值给另一种类型的枚举。在下面的示例中，需要进行显式转换：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace Enums1
{
    class Program
    {
        static void Main(string[] args)
        {
            Gender gender = (Gender)Season.Summer;
            Console.WriteLine("Gender.gender的值是{0}",gender);
            Console.WriteLine("Gender.Male的值是{0}",(int)Gender.Female);
            Console.WriteLine("Season.Summer的值是{0}",Season.Summer);
            Console.ReadLine();
        }
        public enum Gender : int
        { 
            Unknown = 1,
            Male = 2,
            Female = 3
        }
        public enum Season : int
        { 
            Winter = 1,
            Spring = 2,
            Summer = 3
        }
    }
}

 

 了解GetValues()和GetNames()方法函数

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace Enums2
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] Values = (int[])Enum.GetValues(typeof(Gender));
            Console.WriteLine("Gender Enum Values");
            Console.WriteLine("Gender的数据类型是{0}",typeof(Gender));
            foreach (int value in Values)
            {
                Console.WriteLine(value);
            }
            
            Console.WriteLine();
            string[] Names = Enum.GetNames(typeof(Gender));
            Console.WriteLine("Gender Enum Names");
            foreach (string Name in Names)
            {
                Console.WriteLine(Name);
            }
            Console.ReadKey();
        }
        public enum Gender : int
        { 
            Unknow = 1,
            Male =2,
            Female =3
        }
    }
}

 

 不能从其它枚举继承

我们用以下示例理解一下枚举不能继承

 

 当我们编译的时候，会报错，如下：

 

 以上可见，一个枚举不能从其它枚举进行继承。但是，类可以继承枚举嘛？我们用示例看一下：

using System;
namespace EnumsDemo
{
    class Program : WeekDays
    {
        static void Main(string[] args)
        {
            Console.WriteLine((int)WeekDays.Monday);
            Console.WriteLine((int)WeekDays.Sunday);
            Console.WriteLine((int)WeekDays.Tuesday);
            Console.WriteLine((int)WeekDays.Wednesday);
            Console.WriteLine((int)WeekDays.Thursday);
            Console.WriteLine((int)WeekDays.Friday);
            Console.WriteLine((int)WeekDays.Saturday);
            
            Console.ReadKey();
        }
    }
    
    public enum WeekDays
    {
        Sunday,
        Monday,
        Tuesday,
        Wednesday,
        Thursday,
        Friday,
        Saturday
    }
}

运行程序会有如下报错：

 

 上面的错误表明类也不能继承自枚举。这是因为枚举是封闭类，因此适用于封闭类的规则也适用于枚举。

复制枚举成员

让我们创建两个名称相同的枚举成员，如下示例

using System;
namespace EnumsDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((int)Gender.Unknown);
            Console.WriteLine((int)Gender.Male);
            Console.WriteLine((int)Gender.Female);           
            Console.ReadKey();
        }
    }
    
    public enum Gender
    {
        Unknown,
        Male,
        Female,
        Unknown
    }
}

 

 依然会报错。枚举就像类，不能定义两个名称相同的成员。