Come rimuovere un elemento per un enum OR?

Ho un enum come:

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

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

Come potrei rimuovere il colore blu dai colori variabili?

È necessario &con il ~(complemento) di 'BLU'.

L'operatore del complemento essenzialmente inverte o "capovolge" tutti i bit per il tipo di dati specificato. Pertanto, se si utilizza l' ANDoperatore ( &) con un certo valore (chiamiamo quel valore 'X') e il complemento di uno o più bit impostati (chiamiamo quei bit Qe il loro complemento ~Q), l'istruzione X & ~Qcancella tutti i bit impostati in Qda Xe restituisce il risultato.

Quindi, per rimuovere o cancellare i BLUEbit, utilizzare la seguente istruzione:

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

È inoltre possibile specificare più bit da cancellare, come segue:

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

o alternativamente ...

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

Quindi per riassumere:

• X | Q imposta bit Q
• X & ~Q cancella bit Q
• ~X inverte / inverte tutti i bit in X

Le altre risposte sono corrette, ma per rimuovere specificamente il blu da quanto sopra dovresti scrivere:

colors &= ~Blah.BLUE;

And not esso ...............................

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

Pensavo che ciò potesse essere utile per altre persone che sono inciampate qui come me.

Fai attenzione a come gestisci i valori enum che potresti impostare per avere un valore == 0 (a volte può essere utile avere uno stato Inattivo o Inattivo per un enum). Causa problemi quando si fa affidamento su queste operazioni di manipolazione dei bit.

Anche quando hai valori enum che sono combinazioni di altra potenza di 2 valori, ad es

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

In questi casi un metodo di estensione come questo potrebbe tornare utile:

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

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

    return states & ~state;
}

E anche l'equivalente metodo IsSet che gestisce i valori combinati (anche se in modo un po 'confuso)

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;
}

Che dire di xor (^)?

Dato che il FLAG che stai cercando di rimuovere è lì, funzionerà .. in caso contrario, dovrai usare un &.

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;

Per semplificare l'enumerazione del flag e renderlo migliore da leggere evitando i multipli, possiamo usare lo spostamento dei bit. (Da un buon articolo che termina il grande dibattito sulle bandiere Enum )

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

e anche per cancellare tutti i bit

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

Puoi usare questo:

colors &= ~Blah.RED;