Wie entferne ich einen Artikel für eine OR-Aufzählung?

Ich habe eine Aufzählung wie:

public enum Blah
{
    RED = 2,
    BLUE = 4,
    GREEN = 8,
    YELLOW = 16
}

Blah colors = Blah.RED | Blah.BLUE | Blah.YELLOW;

Wie kann ich die Farbe Blau aus den variablen Farben entfernen?

Sie müssen &es mit der ~(Ergänzung) von 'BLAU'.

Der Komplementoperator kehrt im Wesentlichen alle Bits für den gegebenen Datentyp um oder "dreht" sie um. Wenn Sie also den ANDOperator ( &) mit einem Wert (nennen wir diesen Wert 'X') und dem Komplement eines oder mehrerer gesetzter Bits (nennen wir diese Bits Qund deren Komplement ~Q) verwenden, X & ~Qlöscht die Anweisung alle Bits, die gesetzt wurden Qfrom Xund gibt das Ergebnis zurück.

Um die BLUEBits zu entfernen oder zu löschen , verwenden Sie die folgende Anweisung:

colorsWithoutBlue = colors & ~Blah.BLUE
colors &= ~Blah.BLUE // This one removes the bit from 'colors' itself

Sie können auch mehrere zu löschende Bits wie folgt angeben:

colorsWithoutBlueOrRed = colors & ~(Blah.BLUE | Blah.RED)
colors &= ~(Blah.BLUE | Blah.RED) // This one removes both bits from 'colors' itself

oder alternativ ...

colorsWithoutBlueOrRed = colors & ~Blah.BLUE & ~Blah.RED
colors &= ~Blah.BLUE & ~Blah.RED // This one removes both bits from 'colors' itself

Um es zusammenzufassen:

• X | Q setzt Bit (s) Q
• X & ~Q löscht Bit (s) Q
• ~X kippt / invertiert alle Bits in X

Die anderen Antworten sind richtig, aber um Blau von oben zu entfernen, würden Sie schreiben:

colors &= ~Blah.BLUE;

And not es...............................

Blah.RED | Blah.YELLOW == 
   (Blah.RED | Blah.BLUE | Blah.YELLOW) & ~Blah.BLUE;

Dachte, dies könnte für andere Leute nützlich sein, die hier wie ich gestolpert sind.

Seien Sie vorsichtig, wie Sie mit Aufzählungswerten umgehen, für die Sie möglicherweise den Wert == 0 festgelegt haben (manchmal kann es hilfreich sein, für eine Aufzählung den Status "Unbekannt" oder "Leerlauf" zu verwenden). Es verursacht Probleme, wenn Sie sich auf diese Bitmanipulationsoperationen verlassen.

Auch wenn Sie Aufzählungswerte haben, die Kombinationen aus anderen Potenzen von 2 Werten sind, z

public enum Colour
{
    None = 0,  // default value
    RED = 2,
    BLUE = 4,
    GREEN = 8,
    YELLOW = 16,
    Orange = 18  // Combined value of RED and YELLOW
}

In diesen Fällen kann eine solche Erweiterungsmethode nützlich sein:

public static Colour UnSet(this Colour states, Colour state)
{
    if ((int)states == 0)
        return states;

    if (states == state)
        return Colour.None;

    return states & ~state;
}

Und auch die gleichwertige IsSet-Methode, die die kombinierten Werte behandelt (wenn auch etwas hackig)

public static bool IsSet(this Colour states, Colour state)
{
    // By default if not OR'd
    if (states == state)
        return true;

    // Combined: One or more bits need to be set
    if( state == Colour.Orange )
        return 0 != (int)(states & state);

    // Non-combined: all bits need to be set
    return (states & state) == state;
}

Was ist mit xor (^)?

Vorausgesetzt, dass die FLAG, die Sie entfernen möchten, vorhanden ist, funktioniert sie. Wenn nicht, müssen Sie ein & verwenden.

public enum Colour
{
    None = 0,  // default value
    RED = 2,
    BLUE = 4,
    GREEN = 8,
    YELLOW = 16,
    Orange = 18  // Combined value of RED and YELLOW
}

colors = (colors ^ Colour.RED) & colors;

Um die Flag-Aufzählung zu vereinfachen und das Lesen durch Vermeiden von Vielfachen zu verbessern, können wir die Bitverschiebung verwenden. (Aus einem guten Artikel zum Ende der großen Debatte über Enum Flags )

[FLAG]
Enum Blah
{
   RED = 1,
   BLUE = 1 << 1,
   GREEN = 1 << 2,
   YELLOW = 1 << 3
}

und auch alle Bits zu löschen

private static void ClearAllBits()
{
    colors = colors & ~colors;
}

Sie können dies verwenden:

colors &= ~Blah.RED;