From: 011netservice@gmail.com
Date: 2022-04-24
Subject: Enum.txt

----------
20200825

[Flages]屬性表示 Enumeration 為 bit 欄位的集合.
[Flags]
private enum Borders
{
    None = 0,  // 最好定義一個 None 代表0, 或未定義. Use None as the name of the flag enumerated constant whose value is zero
    Left = 1,
    Top = 2,
    Right = 4,
    Bottom = 8,
    All = Left | Top | Right | Bottom,  // bit 欄位可以 bitwise OR運算
}

----------
20200825


FlagsAttribute Class

Indicates that an enumeration can be treated as a bit field; that is, a set of flags.

Examples
The following example illustrates the use of the FlagsAttribute attribute and shows the effect on the ToString method of using FlagsAttribute on an Enum declaration.

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

The preceding example defines two color-related enumerations, SingleHue and MultiHue. The latter has the FlagsAttribute attribute; the former does not. The example shows the difference in behavior when a range of integers, including integers that do not represent underlying values of the enumeration type, are cast to the enumeration type and their string representations displayed. For example, note that 3 cannot be represented as a SingleHue value because 3 is not the underlying value of any SingleHue member, whereas the FlagsAttribute attribute makes it possible to represent 3 as a MultiHue value of Black, Red.


The following example defines another enumeration with the FlagsAttribute attribute and shows how to use bitwise logical and equality operators to determine whether one or more bit fields are set in an enumeration value. You can also use the Enum.HasFlag method to do that, but that is not shown in this example.

using System;

[Flags]
public enum PhoneService
{
   None = 0,
   LandLine = 1,
   Cell = 2,
   Fax = 4,
   Internet = 8,
   Other = 16
}

public class Example
{
   public static void Main()
   {
      // Define three variables representing the types of phone service
      // in three households.
      var household1 = PhoneService.LandLine | PhoneService.Cell |
                       PhoneService.Internet;
      var household2 = PhoneService.None;
      var household3 = PhoneService.Cell | PhoneService.Internet;

      // Store the variables in an array for ease of access.
      PhoneService[] households = { household1, household2, household3 };

      // Which households have no service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has phone service: {1}",
                           ctr + 1,
                           households[ctr] == PhoneService.None ?
                               "No" : "Yes");
      Console.WriteLine();

      // Which households have cell phone service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell phone service: {1}",
                           ctr + 1,
                           (households[ctr] & PhoneService.Cell) == PhoneService.Cell ?
                              "Yes" : "No");
      Console.WriteLine();

      // Which households have cell phones and land lines?
      var cellAndLand = PhoneService.Cell | PhoneService.LandLine;
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell and land line service: {1}",
                           ctr + 1,
                           (households[ctr] & cellAndLand) == cellAndLand ?
                              "Yes" : "No");
      Console.WriteLine();

      // List all types of service of each household?//
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has: {1:G}",
                           ctr + 1, households[ctr]);
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Household 1 has phone service: Yes
//    Household 2 has phone service: No
//    Household 3 has phone service: Yes
//
//    Household 1 has cell phone service: Yes
//    Household 2 has cell phone service: No
//    Household 3 has cell phone service: Yes
//
//    Household 1 has cell and land line service: Yes
//    Household 2 has cell and land line service: No
//    Household 3 has cell and land line service: No
//
//    Household 1 has: LandLine, Cell, Internet
//    Household 2 has: None
//    Household 3 has: Cell, Internet


Remarks
Bit fields are generally used for lists of elements that might occur in combination, whereas enumeration constants are generally used for lists of mutually exclusive elements. Therefore, bit fields are designed to be combined with a bitwise OR operation to generate unnamed values, whereas enumerated constants are not. Languages vary in their use of bit fields compared to enumeration constants.

Attributes of the FlagsAttribute
AttributeUsageAttribute is applied to this class, and its Inherited property specifies false. This attribute can only be applied to enumerations.

Guidelines for FlagsAttribute and Enum
.Use the FlagsAttribute custom attribute for an enumeration only if a bitwise operation (AND, OR, EXCLUSIVE OR) is to be performed on a numeric value.

.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. This means the individual flags in combined enumeration constants do not overlap.

.Consider creating an enumerated constant for commonly used flag combinations. For example, if you have an enumeration used for file I/O operations that contains the enumerated constants Read = 1 and Write = 2, consider creating the enumerated constant ReadWrite = Read OR Write, which combines the Read and Write flags. In addition, the bitwise OR operation used to combine the flags might be considered an advanced concept in some circumstances that should not be required for simple tasks.

.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

.A convenient way to test whether a flag is set in a numeric value is to perform a bitwise AND operation between the numeric value and the flag enumerated constant, which sets all bits in the numeric value to zero that do not correspond to the flag, then test whether the result of that operation is equal to the flag enumerated constant.

.Use None as the name of the flag enumerated constant whose value is zero. You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. However, you can perform a logical, not a bitwise, comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set.

If you create a value enumeration instead of a flags enumeration, it is still worthwhile to create a None enumerated constant. The reason is that by default the memory used for the enumeration is initialized to zero by the common language runtime. Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

If there is an obvious default case your application needs to represent, consider using an enumerated constant whose value is zero to represent the default. If there is no default case, consider using an enumerated constant whose value is zero that means the case that is not represented by any of the other enumerated constants.

.Do not define an enumeration value solely to mirror the state of the enumeration itself. For example, do not define an enumerated constant that merely marks the end of the enumeration. If you need to determine the last value of the enumeration, check for that value explicitly. In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

.Do not specify enumerated constants that are reserved for future use.

.When you define a method or property that takes an enumerated constant as a value, consider validating the value. The reason is that you can cast a numeric value to the enumeration type even if that numeric value is not defined in the enumeration.


----------
enum with flag:
ref:
https://dotblogs.com.tw/yc421206/2015/10/20/c_scharp_enum_of_flags


internal enum EnumPermissionType
{
    None = 0,
    Read = 1,
    Add = 2,
    Edit = 4,
    Delete = 8,
    Print = 16,
    RunFlow = 32,
    Export = 64,
    All = Read | Add | Edit | Delete | Print | RunFlow,
}
 
使用方式也很簡單
OR 運算，加入 permossions
   1:  var permossions = EnumPermissionType.Read | EnumPermissionType.Add;

 
AND 運算：判斷 permossions 是否有項目
   1:  var actual = (permossions & EnumPermissionType.Add) == EnumPermissionType.Add;

 
XOR 運算：從 permossions 移除項目，我知道有兩種寫法
   1:  var removeAdd = (permossions & (EnumPermissionType.All ^ EnumPermissionType.Add));
   2:  var removeAdd = permossions & ~EnumPermissionType.Add;

 
運算完後的結果，可以變成整數，整數也能倒回去變成列舉，程式碼如下：
{ 
    int result; 
    result = (int)((EnumPermissionType)permissionCodes | targetvalue); 
    return result; 
}

private int Remove(int permissionCode, EnumPermissionType targetvalue) 
{ 
    int result; 
    result = (int)((EnumPermissionType)permissionCode & (EnumPermissionType.All ^ targetvalue));

    return result; 
}

private bool IsPermission(int permissionCode, EnumPermissionType targetValue) 
{ 
    var result = false; 
    var permissionTypes = (EnumPermissionType)permissionCode; 
    result = (permissionTypes & targetValue) == targetValue;

    return result; 
}

 
調用端測試
public void Add_TestMethod() 
{ 
    var permossionCode = this.Add(0, EnumPermissionType.Add); 
    var expected = true; 
    var actual = this.IsPermission(permossionCode, EnumPermissionType.Add); 
    Assert.AreEqual(expected, actual); 
}

[TestMethod] 
public void Remove_TestMethod() 
{ 
    var permossionCode = this.Add(0, EnumPermissionType.Add); 
    permossionCode = this.Add(permossionCode, EnumPermissionType.Edit); 
    var expected = false; 
    permossionCode = this.Remove(permossionCode, EnumPermissionType.Add); 
    var actual = this.IsPermission(permossionCode, EnumPermissionType.Add); 
    Assert.AreEqual(expected, actual); 
}

 
最後把它們寫成擴充方法
{
    public static bool Has<TSource>(this Enum source, TSource value)
    {
        var result = false;
        result = ((dynamic)source & (dynamic)value) == (dynamic)value;
        return result;
    }

    public static TSource Add<TSource>(this Enum source, TSource value)
    {
        dynamic result = default(TSource);
        result = (dynamic)source | (dynamic)value;
        return result;
    }

    public static TSource Remove<TSource>(this Enum source, TSource value)
    {
        dynamic result = default(TSource);
        result = (dynamic)source & ~(dynamic)value;
        return result;
    }
}

 
擴充方法調用
public void AddExtented_TestMethod()
{
    var expected = true;
    var initail = EnumPermissionType.None;
    var permissionType = initail.Add(EnumPermissionType.Add).Add(EnumPermissionType.Read);
    var actual = permissionType.Has(EnumPermissionType.Read);
    Assert.AreEqual(expected, actual);
}

[TestMethod]
public void RemoveExtented_TestMethod()
{
    var expected = false;
    var initail = EnumPermissionType.None | EnumPermissionType.Add | EnumPermissionType.Read;
    var permissionType = initail.Remove(EnumPermissionType.Add);
    var actual = permissionType.Has(EnumPermissionType.Add);
    Assert.AreEqual(expected, actual);
}


----------
public enum Color
{
  None,
  Red,
  Green,
  Yellow
}

// enum starts with 0
Color color = Color.None;

...or to use Nullable:
Color? color = null;


----------
using System;

public class ParseTest
{
    [FlagsAttribute]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main()
    {
        Console.WriteLine("The entries of the Colors Enum are:");
        foreach (string colorName in Enum.GetNames(typeof(Colors)))
        {
            Console.WriteLine("{0}={1}", colorName, 
                                         Convert.ToInt32(Enum.Parse(typeof(Colors), colorName)));
        }
        Console.WriteLine();
        Colors myOrange = (Colors)Enum.Parse(typeof(Colors), "Red, Yellow");
        Console.WriteLine("The myOrange value {1} has the combined entries of {0}", 
                           myOrange, Convert.ToInt64(myOrange));
    }
}

/*
This code example produces the following results:

The entries of the Colors Enum are:
Red=1
Green=2
Blue=4
Yellow=8

The myOrange value 9 has the combined entries of Red, Yellow

*/

----------
        //luckstar 10 background-colors:
        public enum enumBackgroundColor {
            Entry = 0xEC39D8, //視窗, Entry, 適合輸入作業
            Red = 0xFFB7DD, //紅, red
            Orange = 0xFFDDAA, //橙, Orange
            Yellow = 0xFFFFBB, // 黃,   yellow
            Green = 0xCCFF99, //綠,   green
            Blue = 0xBBFFEE, //藍,   blue
            Indigo = 0xCCDDFF, //靛,   Indigo
            Purple = 0xF0BBFF, //紫,   purple
            Black = 0x000000, //黑,   black
            White = 0xFFFFFF, //白,   white, 適合列印
        };

        // sample code to get enum
            foreach (string s1 in Enum.GetNames(typeof(enumBackgroundColor)))
            {
                enumBackgroundColor iColor;
                string sHex;
                Console.Write(s1);
                Console.Write("=");
                iColor = (enumBackgroundColor) Enum.Parse(typeof(enumBackgroundColor), s1);
                sHex = string.Format("{0:X}", iColor);
                Console.WriteLine(sHex + ", int=" + iColor);
            }


----------
code1: Enum.Parse


using System;

public class ParseTest {
    [FlagsAttribute]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main() {

        Console.WriteLine("The entries of the Colors Enum are:");
        foreach(string s in Enum.GetNames(typeof(Colors)))
            Console.WriteLine(s);

        Console.WriteLine();

        Colors myOrange = (Colors)Enum.Parse(typeof(Colors), "Red, Yellow");
        Console.WriteLine("The myOrange value has the combined entries of {0}", myOrange);
    }
}

----------
code2:

// keyword_enum.cs
// enum initialization:
using System;
public class EnumTest 
{
    enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

    static void Main() 
    {
        int x = (int)Days.Sun;
        int y = (int)Days.Fri;
        Console.WriteLine("Sun = {0}", x);
        Console.WriteLine("Fri = {0}", y);
    }
}

output:
Sun = 2
Fri = 7


----------
code3:

// keyword_enum2.cs
// Using long enumerators
using System;
public class EnumTest 
{
    enum Range :long {Max = 2147483648L, Min = 255L};
    static void Main() 
    {
        long x = (long)Range.Max;
        long y = (long)Range.Min;
        Console.WriteLine("Max = {0}", x);
        Console.WriteLine("Min = {0}", y);
    }
}

output:
Max = 2147483648
Min = 255


----------
code4:

// enumFlags.cs
// Using the FlagsAttribute on enumerations.
using System;

[Flags]
public enum CarOptions
{
    SunRoof = 0x01,
    Spoiler = 0x02,
    FogLights = 0x04,
    TintedWindows = 0x08,
}

class FlagTest
{
    static void Main()
    {
        CarOptions options = CarOptions.SunRoof | CarOptions.FogLights;
        Console.WriteLine(options);
        Console.WriteLine((int)options);
    }
}


output:
SunRoof, FogLights
5

Notice that if you remove the initializer from Sat=1, the result will be:
Sun = 1
Fri = 6

Notice that if you remove FlagsAttribute, the example will output the following:
5
5