Comment faire pour supprimer un élément pour une OU souhaitez enum?

J'ai un enum comme:

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

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

Comment pourrais-je enlever la couleur bleue de la variable couleurs?

Petite note: un bit à bit enum en C# doit obtenir le [Drapeaux] attribut au-dessus d'elle.
pourriez-vous expliquer pourquoi il devrait obtenir l'attribut?
Il donne une meilleure prise en charge IntelliSense pendant le débogage, car il reconnaît inconnu valeurs enum comme des combinaisons de valeurs existantes.
Il fournit également une plus significatives .ToString() valeur. par exemple, RED, BLUE, YELLOW plutôt que 22.

InformationsquelleAutor Blankman | 2011-01-24

c#enums

279

Vous devez & avec le ~ (compléter) de "BLEU".

L'opérateur de complément essentiellement inverse ou "flips" tous les bits pour le type de données. En tant que tel, si vous utilisez le AND opérateur (&) avec une certaine valeur (appelons cette valeur 'X') et le complément d'un ou de plusieurs bits (appelons ces bits Q et leur complément ~Q), la déclaration X & ~Q efface tous les bits qui ont été mis en Q de X et retourne le résultat.

Donc à supprimer ou effacer l' BLUE bits, vous devez utiliser 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 pour effacer, comme suit:
```
colorsWithoutBlueOrRed = colors & ~(Blah.BLUE | Blah.RED)
colors &= ~(Blah.BLUE | Blah.RED) //This one removes both bits from 'colors' itself
```
ou en alternance...
```
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 jeux de bit(s) Q
- X & ~Q efface le bit(s) Q
- ~X flips/inverse tous les bits dans X
- donc, si j'ai voulu supprimer plus je voudrais juste faire : &= ~Bla.BLUE & ~Bla.Vert ?
- Correct.
- Mieux, c'est colors &= ~( Blah.BLUE | Blah.GREEN );
- comment inhabituelle, je pensais juste la façon de le faire encore une fois sur il y a 5 jours 🙂 Cette question mise à jour dans ma boîte de réception et le tour est joué!
- Grande réponse. Je pense que tu veux dire "&=" non "=&" dans votre code échantillons cependant 😉
InformationsquelleAutor SLaks
41

Les autres réponses sont correctes, mais précisément pour supprimer le bleu de la ci-dessus, on peut écrire:
```
colors &= ~Blah.BLUE;
```
- Court et de réponse claire. Ce sont les meilleures réponses!
- Doux. Court et au point
InformationsquelleAutor par

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

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

InformationsquelleAutor Daniel A. White

7

Pensé que cela pourrait être utile pour d'autres personnes que suis tombé ici, comme moi.

Être prudents dans la façon dont vous gérer toutes les valeurs de l'enum de ce que vous pourriez avoir une valeur == 0 (parfois, il peut être utile de demander à un Inconnu ou à l'état Inactif pour un enum). Il provoque des problèmes lors de l'utilisation de ces opérations de manipulation de bit.

Aussi quand vous avez les valeurs de l'enum qui sont des combinaisons d'autres puissance 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, la méthode d'extension comme cela pourrait être 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 l'équivalent IsSet méthode qui traite les valeurs combinées (quoique un peu à l'hacky façon)
```
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;
}
```
- Il me semble que la solution la plus simple est d'éviter d'utiliser 0 comme un drapeau. J'ai habituellement drapeau énumérations comme ceci. Je ne vois pas comment vous allez bénéficier de la spécification d'un état avec une valeur de 0. Après tout, le point est que vous pouvez vous soucier des programmeurs (les nomsRed, Blue, Green) plutôt que les valeurs sous-jacentes, ouais?
- Avoir un none ou unknown ou unset entrée avec la valeur == 0 est dans de nombreux cas, une bonne chose que vous ne pouvez pas toujours supposer qu'une valeur particulière est le jeu par défaut, par exemple si vous avez seulement le Rouge, le Bleu et le Vert sont que vous allez Rouge comme la valeur par défaut (par exemple, la valeur de l'enum a lors de sa création ou l'utilisateur n'a pas modifié?)
- Ne pouvez-vous pas juste Unset = 1 et l'utilisation 1, 2, 4, 8 que vos valeurs? Si vous avez besoin d'une valeur par défaut, qui est ce que les constructeurs par défaut sont pour la, droite? Je tiens à garder les choses aussi explicites que possible, par souci de lisibilité, et en s'appuyant sur un enum pour défaut de default(int) (0) lorsqu'il n'est pas donné une valeur, en dépit d'être de l'information sans doute connu par n'importe quel développeur, est trop sournois pour mes goûts de toute façon. Edit: Ah, en fait, serait de faire Annuler = 0 empêcher quelque chose de Unset | Blue?
- Vous êtes sur la bonne voie dans votre édition Sinjai, en gardant le unset valeur == 0 résout quelques problèmes. Un être, ce que vous avez mentionné et un autre si vous enlevez toutes les valeurs de l'enum, alors vous n'avez pas besoin d'un cas particulier pour "Détruire" s'il est réglé à zéro. (par exemple, si vous Red & ~Red puis vous vous retrouvez avec zéro, vous devrez avoir le code pour vérifier cette affaire et affecter explicitement le Unset valeur)
- Gotcha. Avez-vous souvent vous trouver en présence avec la fonction unset les drapeaux?
- Chaque fois que je suis en train de travailler sur la consommation des données à partir d'un utilisateur ou une source externe ou de travailler sur tout ce qui est lié à une INTERFACE utilisateur ce terme apparaît. Vous avez souvent besoin de savoir quand la valeur n'a pas été définie par l'utilisateur ou de la source de données des rapports de corruption ou de données manquantes (vous pouvez ne pas attribuer des valeurs par défaut dans tous les cas, si des données sont manquantes)
- Je sais que c'est vieux, mais pour votre Unset méthode si states == 0 puis states & ~state == states votre première branche n'est pas nécessaire. De même, si states == state puis states & ~state == Colour.None ainsi, votre deuxième branche n'est pas nécessaire et vous pouvez simplement retourner states & ~state...
InformationsquelleAutor Sverrir Sigmundarson

Ce sujet xor(^)?

Étant donné que le DRAPEAU que vous tentez de supprimer est là, il va fonctionner.. si non, vous aurez à 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;

InformationsquelleAutor user4509414

0

Vous pouvez utiliser ceci:
```
colors &= ~Blah.RED; 
```
InformationsquelleAutor Majid gharaei
0

Pour simplifier le drapeau enum et de faire peut-être mieux de lire en évitant les multiples, nous pouvons utiliser le décalage de bits.
(À partir d'un bon article Se terminant le Grand Débat sur Enum Drapeaux)
```
[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;
}
```
InformationsquelleAutor Matt Allen

Vous devez vous connecter pour publier un commentaire.