¿Cómo eliminar un elemento para una enumeración OR?

Tengo una enumeración como:

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

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

¿Cómo podría eliminar el color azul de los colores variables?

Lo necesitas &con el ~(complemento) de 'AZUL'.

El operador del complemento esencialmente invierte o 'voltea' todos los bits para el tipo de datos dado. Como tal, si usa el ANDoperador (& ) con algún valor (llamemos a ese valor 'X') y el complemento de uno o más bits de conjunto (llamemos a esos bits Qy su complemento ~Q), la instrucción X & ~Qborra todos los bits que se establecieron en Qde Xy devuelve el resultado.

Entonces, para eliminar o borrar los BLUEbits, use la siguiente declaración:

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

También puede especificar varios bits para borrar, de la siguiente manera:

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

Entonces para resumir:

• X | Q establece bit (s) Q
• X & ~Q borra bit (s) Q
• ~X voltea / invierte todos los bits en X

Las otras respuestas son correctas, pero para eliminar específicamente el azul de lo anterior, escribiría:

colors &= ~Blah.BLUE;

And not eso...............................

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

Pensé que esto podría ser útil para otras personas que tropezaron aquí como yo.

Tenga cuidado al manejar cualquier valor de enumeración que pueda establecer para tener un valor == 0 (a veces puede ser útil tener un estado Desconocido o Inactivo para una enumeración). Causa problemas al confiar en estas operaciones de manipulación de bits.

También cuando tiene valores de enumeración que son combinaciones de otra potencia de 2 valores, p. Ej.

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

En estos casos, un método de extensión como este podría ser útil:

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

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

    return states & ~state;
}

Y también el método IsSet equitativo que maneja los valores combinados (aunque de una manera un poco hacky)

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

¿Qué pasa con xor (^)?

Dado que la BANDERA que está tratando de eliminar está allí, funcionará ... si no, tendrá que usar 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;

Para simplificar la enumeración de la bandera y hacer que sea mejor leer evitando los múltiplos, podemos usar el desplazamiento de bits. (De un buen artículo Terminando el Gran Debate sobre Enum Flags )

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

y también para borrar todos los bits

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

Puedes usar esto:

colors &= ~Blah.RED;