Comment supprimer un élément pour une énumération OR?

J'ai une énumération comme:

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

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

Comment puis-je supprimer la couleur bleue des couleurs variables?

Vous en avez besoin &avec le ~(complément) de 'BLUE'.

L'opérateur de complément inverse ou «retourne» essentiellement tous les bits pour le type de données donné. En tant que tel, si vous utilisez l' ANDopérateur ( &) avec une valeur (appelons cette valeur `` X '') et le complément d'un ou plusieurs bits définis (appelons ces bits Qet leur complément ~Q), l'instruction X & ~Qefface tous les bits définis dans Qfrom Xet renvoie le résultat.

Donc, pour supprimer ou effacer les BLUEbits, vous utilisez l'instruction suivante:

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

Vous pouvez également spécifier plusieurs bits à effacer, comme suit:

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

ou alternativement ...

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

Donc pour résumer:

• X | Q définit le (s) bit (s) Q
• X & ~Q efface le (s) bit (s) Q
• ~X retourne / inverse tous les bits de X

Les autres réponses sont correctes, mais pour supprimer spécifiquement le bleu de ce qui précède, vous écririez:

colors &= ~Blah.BLUE;

And not il...............................

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

J'ai pensé que cela pourrait être utile pour d'autres personnes qui ont trébuché ici comme moi.

Faites attention à la manière dont vous gérez les valeurs d'énumération que vous pourriez définir pour avoir une valeur == 0 (il peut parfois être utile d'avoir un état Inconnu ou Inactif pour une énumération). Cela pose des problèmes lors de l'utilisation de ces opérations de manipulation de bits.

Aussi lorsque vous avez des valeurs d'énumération qui sont des combinaisons d'autres puissances de 2 valeurs, par exemple

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

Dans ces cas, une méthode d'extension telle que celle-ci peut s'avérer 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;
}

Et aussi la méthode IsSet équivilente qui gère les valeurs combinées (bien que de manière un peu 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;
}

Et xor (^)?

Étant donné que le FLAG que vous essayez de supprimer est là, cela fonctionnera. Sinon, vous devrez utiliser 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;

Pour simplifier l'énumération des indicateurs et faire en sorte qu'il soit peut-être préférable de lire en évitant les multiples, nous pouvons utiliser le décalage de bits. (Extrait d'un bon article mettant fin au grand débat sur les drapeaux enum )

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

et aussi pour effacer tous les bits

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

Vous pouvez utiliser ceci:

colors &= ~Blah.RED;