我们重点来讲解 简单枚举和标志枚举的用法和区别

继承

Object-> ValueType ->Enum
Object-> ValueType ->struct 包括int float等简单值类型
Object-> ValueType ->ValueTuple
Object-> ValueType ->Nullable

1、枚举类型 是由基础整型数值类型的一组命名常量定义的值类型。

2.枚举使用enum关键字来声明， 枚举可以和类并列也可以  写在类里面，不能写在方法里。

namespace ConsoleApp1
{
class Program
{
//////////////省略。。。。。。。。。
}
[Flags]
enum Man
{
//////////////省略。。。。。。。。。
}
}

3、枚举都是隐式密封的(sealed)，不允许作为基类派生子类。枚举里面的成员只能是默认公共的静态的(public、static)，不能有访问修饰符;枚举本身一般不加访问修饰符，要加的话只能是internal

或public;

4、枚举成员是常量 不可更改。可以当作字段来用。由于枚举成员在编译时将被替换为字面量，使得其成员取值类型受到了一定限制。

public readonly int SOU = 12;
public const int seiu = 12;
enum n { i=0}
编译后的iL代码
.field public initonly int32 SOU
.field public static literal int32 seiu = int32(12)
.field public static literal valuetype Galaxy.Program/n i = int32(0)
//枚举中字段IL代码和Const 常量定义的IL代码是一样的，编译时常数，在编译时是已知的，在程序的生命周期内不会改变

5、默认情况下,枚举成员的关联常数值为类型 int（被编译查成IL：.field public specialname rtspecialname int32 value__） ;它们从零开始,并按定义文本顺序递增 1。 可以显式指定任何
其他整数数值类型作为枚举类型的基础类型。 还可以显式指定关联的常数值,如下面的示例所示:

enum ErrorCode : int //不是继承，只是写法像继承，查看IL代码 被编译成.field public specialname rtspecialname int32 value__，如果是继承应该显示extends
{
None = 0,
Unknown = 1,
ConnectionLost = 100,
OutlierReading = 200
}

6、枚举元素不可以重复，枚举元素的值可以重复。最后一个元素后的逗号可有可无。枚举最后的冒号可有可无。

7、 基础类型指定为每个枚举数分配的存储大小。

System.Enum 类型是所有枚举类型的抽象基类。 它提供多种方法来获取有关枚举类型及其值的信息。 有关更多
信息和示例,请参阅 System.Enum API 参考页。
从 C# 7.3 开始,你可以在基类约束中使用 System.Enum (称为枚举约束),以指定类型参数为枚举类型。 所有枚举
类型也都满足 struct 约束,此约束用于指定类型参数为不可为 null 的值类型。

对于任何枚举类型,枚举类型与其基础整型类型之间存在显式转换。 如果将枚举值转换为其基础类型,则结果为
枚举成员的关联整数值。

public enum Season
{
Spring,
Summer,
Autumn,
Winter
}
public class EnumConversionExample
{
public static void Main()
{
Season a = Season.Autumn;
Console.WriteLine($"Integral value of {a} is {(int)a}"); // output: Integral value of Autumn is 2
var b = (Season)1;
Console.WriteLine(b); // output: Summer
}
}

使用 Enum.IsDefined 方法来确定枚举类型是否包含具有特定关联值的枚举成员。
对于任何枚举类型,都存在分别与 System.Enum 类型的装箱和取消装箱相互转换。

枚举类型的作用是限制其变量只能从有限的选项中取值，这些选项（枚举类型的成员）各自对应于一个数字，数字默认从 0 开始，并以此递增。例如：

public enum Days{    Sunday, Monday, Tuesday, // ...}

其中 Sunday 的值是 0，Monday 是 1，以此类推。为了一眼能看出每个成员代表的值，一般推荐显示地将成员值写出来，不要省略：

public enum Days{    Sunday = 0, Monday = 1, Tuesday = 2, // ...}

C# 枚举成员的类型默认是 int 类型，通过继承可以声明枚举成员为其它类型，比如：

publicenum Days : byte{    Monday = 1,    Tuesday = 2,    Wednesday = 3,    Thursday = 4,    Friday = 5,    Saturday = 6,    Sunday = 7}

枚举类型一定是继承自 byte、sbyte、short、ushort、int、uint、long 和 ulong 中的一种，不能是其它类型。下面是几个枚举的常见用法（以上面的 Days 枚举为例）：

// 枚举转字符串string foo = Days.Saturday.ToString(); // "Saturday"string foo = Enum.GetName(typeof(Days), 6); // "Saturday"// 字符串转枚举Enum.TryParse("Tuesday", out Days bar); // true, bar = Days.Tuesday(Days)Enum.Parse(typeof(Days), "Tuesday"); // Days.Tuesday// 枚举转数字byte foo = (byte)Days.Monday; // 1// 数字转枚举Days foo = (Days)2; // Days.Tuesday// 获取枚举所属的数字类型Type foo = Enum.GetUnderlyingType(typeof(Days))); // System.Byte// 获取所有的枚举成员Array foo = Enum.GetValues(typeof(MyEnum);// 获取所有枚举成员的字段名string[] foo = Enum.GetNames(typeof(Days));

另外，值得注意的是，枚举可能会得到非预期的值（值没有对应的成员）。比如：

Days d = (Days)21; // 不会报错Enum.IsDefined(typeof(Days), d); // false

即使枚举没有值为 0 的成员，它的默认值永远都是 0。

var z = default(Days); // 0

枚举可以通过 Description、Display 等特性来为成员添加有用的辅助信息，比如：

public enum ApiStatus
{
[Description("成功")]
OK = 0,
[Description("资源未找到")]
NotFound = 2,
[Description("拒绝访问")]
AccessDenied = 3
}

static class EnumExtensions
{
public static string GetDescription(this Enum val)
{
var field = val.GetType().GetField(val.ToString());
var customAttribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute));
if (customAttribute == null) { return val.ToString(); }
else { return ((DescriptionAttribute)customAttribute).Description; }
}
}

static void Main(string[] args)
{
Console.WriteLine(ApiStatus.Ok.GetDescription()); // "成功"
}

上面这些我认为已经包含了大部分我们日常用到的枚举知识了。下面我们继续回到文章开头说的用户角色存储问题。

2.1 标志枚举的使用准则

避免创建标志枚举，其中某些值的组合无效。

避免使用值为零的标记枚举值，除非该值表示 "所有标志均已清除" 并正确命名，如下一个准则所述。

️ DO name 标记枚举的零值 None 。 对于标志枚举，值始终为 "清除所有标志"。

2.2三种写法都是等效的；

第一种写法：位数大了以后不容易察觉错误；

第二中写法：推荐，容易理解 标志枚举是如何运作的。

第三种写法：容易阅读，但是有个bug，当移位超出整形限制范围时候，编译器不会报错,计算结果失效。曹操不是兄弟，但是在int整型范围之下 1<<62 和1<<30 值是一样的，导致计算结果出错。

static void Main(string[] args)
{
Man xiongdi = Man.关羽 | Man.刘备 | Man.张飞;

        if((xiongdi.HasFlag(Man.曹操)))  
        Console.WriteLine($"{Man.司马懿}是兄弟");//司马懿是兄弟  
        if ((xiongdi.HasFlag(Man.关羽)))  
            Console.WriteLine($"{Man.关羽}是兄弟");//关羽是兄弟

    }  
    \[Flags\]  
    enum Man  
    {  
        曹操=1<<30,//IL反编译显示：曹操 = 0x40000000,  
        司马懿 =1<<31,//IL反编译显示：司马懿 = int.MinValue,  
        刘备 =1<<32,//IL反编译显示：刘备 = 0x1,  
        关羽 =1<<33,//IL反编译显示：关羽 = 0x2,  
        张飞 =1<<62,//IL反编译显示：张飞 = 0x40000000

    }

每当可枚举表示可能值的集合而不是单个值时，应使用[Flags]属性。此类集合通常与按位运算符一起使用，例如：

var allowedColors = MyColor.Red | MyColor.Green | MyColor.Blue;

请注意，[Flags]属性本身并不启用此功能，它所做的只是允许.ToString()方法的良好表示：

enum Suits { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }
[Flags] enum SuitsFlags { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }

…

var str1 = (Suits.Spades | Suits.Diamonds).ToString();
//"5"
var str2 = (SuitsFlags.Spades | SuitsFlags.Diamonds).ToString();
//"Spades, Diamonds"

还需要注意的是，[Flags]不会自动使枚举值的幂为2。如果省略数字值，枚举将不会像在按位操作中预期的那样工作，因为默认情况下，值以0和增量开头。

      Console.WriteLine(default(Man)); //枚举的默认值都是0

声明不正确：

[Flags]
public enum MyColors
{
Yellow, // 0
Green, // 1
Red, // 2
Blue // 3
}

如果以这种方式声明，值将为黄色=0、绿色=1、红色=2、蓝色=3。这将使其作为标志无效。

以下是正确声明的示例：

[Flags]
public enum MyColors
{
Yellow = 1,
Green = 2,
Red = 4,
Blue = 8
}

2.3位枚举使用案例

//1、给用户创建、读取，修改和删除的权限
var parmission = Permission.Create | parmission.Read | parmission.Update | parmission.Delete;

//2、去掉用户的修改和删除权限
parmission = parmission &~parmission.Update;
parmission = parmission &~parmission.Delete;

//3、给用户加上修改的权限
parmission = parmission | parmission.Update;

//4、判断用户是否有创建的权限
var isCreate =(myProperties.AllowedColors.HasFlag(MyColor.Yellow);

或在.NET 4之前：

if((myProperties.AllowedColors & MyColor.Yellow) == MyColor.Yellow)
{
// Yellow is allowed…
}

if((myProperties.AllowedColors & MyColor.Green) == MyColor.Green)
{
// Green is allowed…
}

using System;

class Example
{
// Define an Enum without FlagsAttribute.
enum SingleHue : short
{
None = 0,
Black = 1,
Red = 2,
Green = 4,
Blue = 8
};

// Define an Enum with FlagsAttribute.
[Flags]
enum MultiHue : short
{
None = 0,
Black = 1,
Red = 2,
Green = 4,
Blue = 8
};

static void Main( )
{
// Display all possible combinations of values.
Console.WriteLine(
"All possible combinations of values without FlagsAttribute:");
for(int val = 0; val <= 16; val++ )
Console.WriteLine( "{0,3} - {1:G}", val, (SingleHue)val);

  // Display all combinations of values, and invalid values.  
  Console.WriteLine(  
       "\\nAll possible combinations of values with FlagsAttribute:");  
  for( int val = 0; val <= 16; val++ )  
     Console.WriteLine( "{0,3} - {1:G}", val, (MultiHue)val);  

}
}
// The example displays the following output:
// All possible combinations of values without FlagsAttribute:
// 0 - None
// 1 - Black
// 2 - Red
// 3 - 3
// 4 - Green
// 5 - 5
// 6 - 6
// 7 - 7
// 8 - Blue
// 9 - 9
// 10 - 10
// 11 - 11
// 12 - 12
// 13 - 13
// 14 - 14
// 15 - 15
// 16 - 16
//
// All possible combinations of values with FlagsAttribute:
// 0 - None
// 1 - Black
// 2 - Red
// 3 - Black, Red
// 4 - Green
// 5 - Black, Green
// 6 - Red, Green
// 7 - Black, Red, Green
// 8 - Blue
// 9 - Black, Blue
// 10 - Red, Blue
// 11 - Black, Red, Blue
// 12 - Green, Blue
// 13 - Black, Green, Blue
// 14 - Red, Green, Blue
// 15 - Black, Red, Green, Blue
// 16 - 16

前面的示例定义了两个与颜色相关的枚举： SingleHue 和 MultiHue 。 后者具有 FlagsAttribute 属性; 前者不具有属性。 此示例显示了在一个整数范围（包括不表示枚举类型的基础值的整数）转换为枚举类型及其显示的字符串表示形式时的行为差异。 例如，请注意，3不能表示为 SingleHue 值，因为3不是任何成员的基础值 SingleHue ，而特性使你可以将 FlagsAttribute 3 表示为 MultiHue 的值 Black, Red 。

foreach (var f in Enum.GetValues(typeof(FileSystemRights)))
{
Console.WriteLine(f.ToString().PadLeft(28) + Convert.ToString((int)f, 2).PadLeft(32, '0'));
}

　　1. 权限的加法, 使用与运算来实现。

　　0001 | 0100 = 0101, 表示同时具有第一位和第三位的权限管理了, 枚举表示为:

1 Permissions per = Permissions.Insert | Permissions.Update

　　2. 权限的减法, 使用与运算+非运算来实现。

　　如上面要去掉Insert权限, 操作为:

1 Permissions per &= ~Permissions.Insert
2 // 即是
3 0101 & ~0001 = 0101 & 1110 = 0100

　　3. 权限的判断, 使用与运算。

　　判断是否有操作权限时, 把用户的的权限与操作权限进行与运算, 如果得到的结果仍是操作权限管理, 则表示用户具有该权限:

1 　　Permissions per = Permissions.Insert | Permissions.Update;
2 　　if(（per & Permissions.Insert）== Permissions.Insert)
3 　　{
4 　　//有操作权限
5 　　}

　　比较过程为 0101 & 0001 = 0001, 0001的0位用与C#位运算把其它位都置成0, 变成只比较1的这一位.