C# Bitwise Enum-Operationen: Ein prägnanter Spickzettel?

Gemeinsame Bitoperationen in C#-Aufzählungen

Dieser Artikel soll Entwicklern helfen, gängige Aufzählungsbitoperationen in C# zu verstehen.

Frage:

Bei bitweisen Operationen in Aufzählungen ist es immer verwirrend, wie man einzelne Bits setzt, löscht, umschaltet oder testet. Diese Vorgänge werden nicht häufig verwendet und können daher leicht vergessen werden. Ein „Bit-Operations-Spickzettel“ wird sehr hilfreich sein.

Beispiel:

<code class="language-csharp">flags = flags | FlagsEnum.Bit4;  // 设置第 4 位。</code>

oder

<code class="language-csharp">if ((flags & FlagsEnum.Bit4) == FlagsEnum.Bit4) // 是否有更简洁的方法？</code>

Können Sie Beispiele für alle anderen gängigen Vorgänge nennen? Es ist besser, C#-Syntax und [Flags]-Enumerationen zu verwenden.

Antwort:

Um dieses Problem zu lösen, haben einige Entwickler Erweiterungsmethoden erstellt, die System.Enum erweitern und diese Methoden bequemer zu verwenden sind.

<code class="language-csharp">namespace Enum.Extensions
{
    public static class EnumerationExtensions
    {
        public static bool Has<T>(this System.Enum type, T value)
        {
            try
            {
                return (((int)(object)type & (int)(object)value) == (int)(object)value);
            }
            catch
            {
                return false;
            }
        }

        public static bool Is<T>(this System.Enum type, T value)
        {
            try
            {
                return (int)(object)type == (int)(object)value;
            }
            catch
            {
                return false;
            }
        }

        public static T Add<T>(this System.Enum type, T value)
        {
            try
            {
                return (T)(object)(((int)(object)type | (int)(object)value));
            }
            catch (Exception ex)
            {
                throw new ArgumentException(
                    string.Format(
                        "无法将值添加到枚举类型 '{0}'。",
                        typeof(T).Name
                        ), ex);
            }
        }

        public static T Remove<T>(this System.Enum type, T value)
        {
            try
            {
                return (T)(object)(((int)(object)type & ~(int)(object)value));
            }
            catch (Exception ex)
            {
                throw new ArgumentException(
                    string.Format(
                        "无法从枚举类型 '{0}' 中移除值。",
                        typeof(T).Name
                        ), ex);
            }
        }
    }
}</code>

Diese Methoden können wie folgt verwendet werden:

<code class="language-csharp">SomeType value = SomeType.Grapes;
bool isGrapes = value.Is(SomeType.Grapes); // true
bool hasGrapes = value.Has(SomeType.Grapes); // true

value = value.Add(SomeType.Oranges);
value = value.Add(SomeType.Apples);
value = value.Remove(SomeType.Grapes);

bool hasOranges = value.Has(SomeType.Oranges); // true
bool isApples = value.Is(SomeType.Apples); // false
bool hasGrapes = value.Has(SomeType.Grapes); // false</code>

Das obige ist der detaillierte Inhalt vonC# Bitwise Enum-Operationen: Ein prägnanter Spickzettel?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!