Como remover um item para uma enumeração OR'd?

Eu tenho um enum como:

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

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

Como remover a cor azul das cores variáveis?

Você precisa fazer &isso com o ~(complemento) de 'AZUL'.

O operador complemento essencialmente reverte ou 'vira' todos os bits para o tipo de dados fornecido. Assim, se você usar o ANDoperador ( &) com algum valor (vamos chamar esse valor de 'X') e o complemento de um ou mais bits definidos (vamos chamar esses bits Qe seu complemento ~Q), a instruçãoX & ~Q limpará todos os bits que foram configurados em Qfrom Xe retorna o resultado.

Portanto, para remover ou limpar os BLUEbits, use a seguinte instrução:

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

Você também pode especificar vários bits para limpar, da seguinte maneira:

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

ou alternadamente ...

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

Então, para resumir:

• X | Q define bit (s) Q
• X & ~Q limpa bit (s) Q
• ~X vira / inverte todos os bits X

As outras respostas estão corretas, mas para remover especificamente o azul das opções acima, você deve escrever:

colors &= ~Blah.BLUE;

And not isto...............................

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

Achei que isso poderia ser útil para outras pessoas que tropeçaram aqui como eu.

Tenha cuidado ao lidar com quaisquer valores de enumeração que você pode definir para ter um valor == 0 (às vezes pode ser útil ter um estado Desconhecido ou Inativo para uma enumeração). Causa problemas ao confiar nessas operações de manipulação de bits.

Além disso, quando você tem valores de enumeração que são combinações de outra potência de 2 valores, por exemplo,

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

Nesses casos, um método de extensão como esse pode 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;
}

E também o método IsSet equivalente que lida com os valores combinados (embora de um jeito meio 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;
}

E o xor (^)?

Dado que o FLAG que você está tentando remover está lá, ele funcionará. Caso contrário, você precisará usar um &.

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 a enumeração do sinalizador e facilitar a leitura, evitando múltiplos, podemos usar a mudança de bits. (De um bom artigo Terminando o Grande Debate sobre Bandeiras Enum )

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

e também para limpar todos os bits

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

Você pode usar isto:

colors &= ~Blah.RED;