// 每个符号标识一种颜色, 也可以用0标识白色
internal enum Color
{
  White,    // 赋值0
  Red,      // 赋值1
  Green,    // 赋值2
  Blue,     // 赋值3
  Orange    // 赋值4
}

// 此代码是伪类型定义,用来了解内部的工作方式
// 实际上编译器不会编译以下代码,禁止定义从System.Enum派生的类型.
internal struct Color : System.Enum
{
  // 以下是一些公共常量,它们定义了Color的符号和值
  public const Color White  = (Color)0;
  public const Color Red    = (Color)1;
  ....

  // 以下是一个公共实例字段.包含Color变量的值
  // 不能写代码来直接引用该字段
  public Int32 value__;
}

public static Type GetUnderlyingType (Type enumType); //System.Enum中定义
public Type GetEnumUnderlyingType (Type enumType);    //System.Type中定义

internal enum Color : byte
{
  White,
  Red,
  Green
}

// 以下代码都会显示 System.Byte
Console.WriteLine(Enum.GetUnderlyingType(typeof(Color)));
Console.WriteLine(typeof(Color).GetEnumUnderlyingType());

class Program
{
    public static void Main(string[] args)
    {
        Color c = Color.Green;
        Console.WriteLine(c);                            // Green
        Console.WriteLine(c.ToString());                 // Green
        Console.WriteLine(c.ToString("G"));              // Green 常规格式
        Console.WriteLine(c.ToString("D"));              // 2     十进制
        // 使用十六进制是, ToStirng总是输出大写字母
        // 输出的位数取决于枚举的基础类型
        // byte/sbyte: 2位, short/ushort: 4位 int/uint:8位 long/ulong: 16位
        // 如果有必要会添加前导零
        Console.WriteLine(c.ToString("X"));              // 02    十六进制
        Console.WriteLine(Color2.Green.ToString("X"));   // 00000002 十六进制
    }
}

internal enum Color : byte
{
    White,
    Red,
    Green
}
internal enum Color2 : int
{
    White,
    Red,
    Green
}

// 比ToString方法好的一个地方是,允许为value传递参数的值,这样就不需要获取枚举的实例
public static String Format(Type enumType,Object value, String format);

// 输出: Blue
Console.WriteLine(Enum.Format(typeof(Color), 3, "G"));

// 返回的数组中每个元素都对应枚举类型中的一个符号名称,每个元素都包含符号名称的数值
public static Array GetValues(Type enumType); //System.Enum中定义
public Array GetEnumValues(Type enumType);    //System.Type中定义

// 返回一个数组
Color[] colors = (Color[]) Enum.GetValues(typeof(Color));

Console.WriteLine("定义枚举的个数: " + colors.Length);
Console.WriteLine("Value\tSymbol\n-----\t------");

foreach (Color color in colors)
{
    // 以十进制和常规格式显示每个符号
    // 0代表第0个参数, {0,5:D} 5个占位符,color的十进制   {0:G} color的常规格式(符号名称)
    Console.WriteLine("{0,5:D}\t{0:G}", color);
}
//    输出:
//    定义枚举的个数: 3
//    Value Symbol
//    -----   ------
//        0   White
//        1   Red
//        2   Green

// 使用下面自定义的泛型方法可以获得更好的编译时类型安全性
public static TEnum[] GetEnumValues<TEnum>() where TEnum :struct
 {
     return (TEnum[]) Enum.GetValues(typeof(TEnum));
 }

 // 使用如下
 Color[] colors = GetEnumValues<Color>();

// 返回数值的字符串表示
public static String GetName(Type enumType, Object value); // System.Enum中定义
public String GetEnumName(Object value); // System.Type中定义

// 返回一个String数组,枚举中每个符号都对应一个String
public static String[] GetName(Type enumType);// System.Enum中定义
public String[] GetEnumName();  // System.Type中定义

public static Object Parse(Type enumType, String value);
public static Object Parse(Type enumType, String value, Boolean ignoreCase);
public static Boolean TryParse<TEnum>(String value, out TEnum result) where TEnum : struct;
public static Boolean TryParse<TEnum>(String value, Boolean ignoreCase, out TEnum result) where TEnum : struct;


// 使用方法
// 因为orange定义为4, 所有c被初始化为4
Color c = (Color) Enum.Parse(typeof(Color), "orange", true);

// 运行时异常, 没有定义此Brown符号
// Color c1 = (Color) Enum.Parse(typeof(Color), "Brown", false);

// 创建值为1的Color枚举类型的实例.
Enum.TryParse<Color>("1", false, out c);
Console.WriteLine(c.ToString("D")  + ":" + typeof(Color).GetEnumName(c));

// 创建值23的Color枚举类型的实例.
Enum.TryParse<Color>("23", false, out c);
Console.WriteLine(c + ":" + typeof(Color).GetEnumName(c));

public static Boolean IsDefined(Type enumType, Object value); // System.Enum中定义
public Boolean IsEnumDefined(Object value);// System.Type中定义


// 用法
// 输出 true , Red定义为1
Console.WriteLine(Enum.IsDefined(typeof(Color),1));
// 输出 true , white定义为0
Console.WriteLine(Enum.IsDefined(typeof(Color),"White"));

// 输出 false , 会检查区分大小写,并没有定义小写的white
Console.WriteLine(Enum.IsDefined(typeof(Color),"white"));
// 输出 false , 没有和值10对应的符号
Console.WriteLine(Enum.IsDefined(typeof(Color),10));

// IsDefined方法经常用于参数校验.
public void SetColor(Color c)
{
    if (!Enum.IsDefined(typeof(Color),c))
    {
        throw (new ArgumentOutOfRangeException("c",c,"无效颜色值."));
    }
    //.....
}

[Flags]
// Int32 有4个字节 每个字节8个位
public enum FileAttributes
{
    //                十进制        二进制
    ReadOnly          = 1,      // 0001
    Hidden            = 2,      // 0010
    System            = 4,      // 0100
    Directory         = 16,     // 0001 0000
    Archive           = 32,     // 0010 0000
    Device            = 64,     // 0100 0000
    Normal            = 128,    // 1000 0000
    Temporary         = 256,    // 0001 0000 0000
    SparseFile        = 512,    // 0010 0000 0000
    ReparsePoint      = 1024,   // 0100 0000 0000
    Compressed        = 2048,   // 1000 0000 0000
    Offline           = 4096,   // 0001 0000 0000 0000
    NotContentIndexed = 8192,   // 0010 0000 0000 0000
    Encrypted         = 16384,  // 0100 0000 0000 0000
    IntegrityStream   = 32768,  // 1000 0000 0000 0000
    NoScrubData       = 131072, // 0010 0000 0000 0000 0000
}
// 判断文件是否隐藏可以执行以下代码:
String file = Assembly.GetEntryAssembly().Location;
// 获取文件的特性的枚举位标志
FileAttributes attributes = File.GetAttributes(file);
// 用& 与操作进行判断,如果attributes对应的Hidden位标志是1,那么1&1 就是true.
Console.WriteLine("Is {0} hidden? {1}", file, (attributes & FileAttributes.Hidden) != 0);
// HasFlag方法获取Enum参数,Enum参数是引用类型.
// Console.WriteLine("Is {0} hidden? {1}", file, attributes.HasFlag(FileAttributes.Hidden) );

// 设置文件只读和隐藏特性
// 用 |
File.SetAttributes(file, FileAttributes.Hidden | FileAttributes.ReadOnly);

class Program
{
    static void Main(string[] args)
    {
        var f = Fruit.Apple;
        var result = f.HasFlag(Fruit.Apple);

        Console.ReadLine();
    }
}

[Flags]
enum Fruit
{
    Apple
}

.method private hidebysig static
    void Main (
        string[] args
    ) cil managed
{
    // Method begins at RVA 0x2050
    // Code size 28 (0x1c)
    .maxstack 2
    .entrypoint
    .locals init (
        [0] valuetype ConsoleApplication1.Fruit f,
        [1] bool result
    )

    IL_0000: nop
    IL_0001: ldc.i4.0
    IL_0002: stloc.0
    IL_0003: ldloc.0
    IL_0004: box ConsoleApplication1.Fruit
    IL_0009: ldc.i4.0
    IL_000a: box ConsoleApplication1.Fruit
    IL_000f: call instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum)
    IL_0014: stloc.1
    IL_0015: call string [mscorlib]System.Console::ReadLine()
    IL_001a: pop
    IL_001b: ret
} // end of method Program::Main

// 结果是什么都没输出
static void Main()  
{  
    Type t = typeof(System.Enum);  

    if (t.IsEnum)  
        Console.WriteLine("I'm enum type.");  

    if (t.IsValueType)  
        Console.WriteLine("I'm value type.");  
}

public static void Main(string[] args)
{
    // 现在数值为0x0005
    Actions actions = Actions.Read | Actions.Delete;
    // 输出: Read, Delete
    Console.WriteLine(actions.ToString());
}

// 加上特性类型[Flag],ToString方法会试图转换为对应的符号,
// 但是0x0005没有对应的值,不过方法检测到[Flag]标志,不会把他视为单独的值
// 会视为一组位标志 0x0005由0x0001和0x0004组合而成,会输出Read, Delete字符串
[Flags]
internal enum Actions
{
    None      = 0b0,
    Read      = 0b1,
    Write     = 0b10,  // 0x2
    ReadWrite = Actions.Read | Actions.Write, //0x5
    Delete    = 0b100, // 0x4
    Query     = 0b1000,// 0x8
    Sync      = 0b10000//0x10
}

class Program
{
    public static void Main(string[] args)
    {
        FileAttributes fa = FileAttributes.System;
        fa = fa.Set(FileAttributes.ReadOnly);
        fa = fa.Clear(FileAttributes.System);
        // 输出: ReadOnly
        fa.ForEach(f=>Console.WriteLine(f));

    }
}

// 先定义一个包含了扩展方法的静态类
internal static class FileAttributesExtensionMethod
{
    public static Boolean IsSet(this FileAttributes flags, FileAttributes flagToTest)
    {
        if (flagToTest == 0)
        {
            throw new ArgumentOutOfRangeException("flagToTest","值不能为0.");
        }
        return (flags & flagToTest) == flagToTest;
    }

    public static Boolean IsClear(this FileAttributes flags, FileAttributes flagToTest)
    {
        if (flagToTest == 0)
        {
            throw new ArgumentOutOfRangeException("flagToTest","值不能为0.");
        }
        return  ! IsSet(flags,flagToTest);
    }

    public static Boolean AnyFlagSet(this FileAttributes flags, FileAttributes testFlag)
    {
        return ((flags & testFlag) != 0);
    }

    public static FileAttributes Set(this FileAttributes flags, FileAttributes setFlag)
    {
        return flags | setFlag;
    }

    public static FileAttributes Clear(this FileAttributes flags, FileAttributes clearFlag)
    {
        return flags & ~clearFlag;
    }

    public static void ForEach(this FileAttributes flags, Action<FileAttributes> processFlag)
    {
        if (processFlag == null)
        {
            throw new ArgumentNullException("processFlag");
        }

        for (UInt32 bit = 1; bit != 0; bit <<= 1)
        {
            UInt32 temp = ((UInt32) flags) & bit;
            if (temp!=0)
            {
                processFlag((FileAttributes) temp);
            }
        }
    }
}