Littéraux binarys C #

Est-il possible d’écrire des littéraux binarys en C #, comme préfixer l’hexadécimal avec 0x? 0b ne fonctionne pas.

Si non, quel est le moyen le plus simple de le faire? Une sorte de conversion de chaîne?

C # 7.0 prend en charge les littéraux binarys (et les séparateurs de chiffres facultatifs via des caractères de soulignement).

Un exemple:

 int myValue = 0b0010_0110_0000_0011; 

Vous pouvez également trouver plus d’informations sur la page Roslyn GitHub .

Mettre à jour

C # 7.0 a maintenant des littéraux binarys, ce qui est génial.

 [Flags] enum Days { None = 0, Sunday = 0b0000001, Monday = 0b0000010, // 2 Tuesday = 0b0000100, // 4 Wednesday = 0b0001000, // 8 Thursday = 0b0010000, // 16 Friday = 0b0100000, // etc. Saturday = 0b1000000, Weekend = Saturday | Sunday, Weekdays = Monday | Tuesday | Wednesday | Thursday | Friday } 

Poste d’origine

Puisque le sujet semble avoir tourné à la déclaration de valeurs de drapeau basées sur des bits dans des énumérations, j’ai pensé qu’il serait utile de faire une astuce pratique pour ce genre de chose. L’opérateur de décalage à gauche ( < < ) vous permettra de pousser un peu vers une position binary spécifique. Combinez cela avec la possibilité de déclarer des valeurs d'énumération en termes d'autres valeurs dans la même classe, et vous avez une syntaxe déclarative très facile à lire pour les énumérations d'indicateurs de bits.

 [Flags] enum Days { None = 0, Sunday = 1, Monday = 1 < < 1, // 2 Tuesday = 1 << 2, // 4 Wednesday = 1 << 3, // 8 Thursday = 1 << 4, // 16 Friday = 1 << 5, // etc. Saturday = 1 << 6, Weekend = Saturday | Sunday, Weekdays = Monday | Tuesday | Wednesday | Thursday | Friday } 

Seul entier et hexadécimal directement, j’ai peur (ECMA 334v4):

9.4.4.2 Littéraux de nombres entiers Les littéraux de nombres entiers sont utilisés pour écrire des valeurs de types int, uint, long et ulong. Les littéraux entiers ont deux formes possibles: décimal et hexadécimal.

Pour parsingr, vous pouvez utiliser:

 int i = Convert.ToInt32("01101101", 2); 

En ajoutant à la réponse de @ SsortingplingWarrior à propos des indicateurs de bits dans les énumérations, il existe une convention simple que vous pouvez utiliser en hexadécimal pour compter à travers les décalages de bits. Utilisez la séquence 1-2-4-8, déplacez une colonne vers la gauche et répétez.

 [Flags] enum Scenery { Trees = 0x001, // 000000000001 Grass = 0x002, // 000000000010 Flowers = 0x004, // 000000000100 Cactus = 0x008, // 000000001000 Birds = 0x010, // 000000010000 Bushes = 0x020, // 000000100000 Shrubs = 0x040, // 000001000000 Trails = 0x080, // 000010000000 Ferns = 0x100, // 000100000000 Rocks = 0x200, // 001000000000 Animals = 0x400, // 010000000000 Moss = 0x800, // 100000000000 } 

Scannez en commençant par la colonne de droite et remarquez le motif 1-2-4-8 (décalage) 1-2-4-8 (décalage) …


Pour répondre à la question initiale, j’ai secondé la suggestion de Sahuagin d’utiliser des littéraux hexadécimaux. Si vous travaillez avec des nombres binarys assez fréquents pour que cela vous préoccupe, il vaut la peine de vous familiariser avec l’hexadécimal.

Si vous avez besoin de voir des nombres binarys dans le code source, je suggère d’append des commentaires avec des littéraux binarys comme ci-dessus.

Vous pouvez toujours créer des quasi-littéraux, des constantes contenant la valeur que vous recherchez:

 const int b001 = 1; const int b010 = 2; const int b011 = 3; // etc ... Debug.Assert((b001 | b010) == b011); 

Si vous les utilisez souvent, vous pouvez les encapsuler dans une classe statique pour les réutiliser.

Cependant, peu importe le sujet, si vous avez une sémantique associée aux bits (connue au moment de la compilation), je vous suggérerais plutôt d’utiliser Enum:

 enum Flags { First = 0, Second = 1, Third = 2, SecondAndThird = 3 } // later ... Debug.Assert((Flags.Second | Flags.Third) == Flags.SecondAndThird); 

Si vous examinez l’ état d’implémentation des fonctionnalités linguistiques de la plate-forme de compilation .NET (“Roslyn”), vous pouvez clairement voir que cette fonctionnalité est prévue dans C # 6.0. Nous pouvons donc le faire normalement.

Statut littéral binaire

 ssortingng sTable="static class BinaryTable\r\n{"; ssortingng stemp = ""; for (int i = 0; i < 256; i++) { stemp = System.Convert.ToString(i, 2); while(stemp.Length<8) stemp = "0" + stemp; sTable += "\tconst char nb" + stemp + "=" + i.ToString() + ";\r\n"; } sTable += "}"; Clipboard.Clear(); Clipboard.SetText ( sTable); MessageBox.Show(sTable); 

En l'utilisant, pour le binary 8 bits, je l'utilise pour créer une classe statique et la place dans le presse-papiers. Ensuite, elle est collée dans le projet et ajoutée à la section Using, de sorte que tout élément avec nb001010 est sorti d'une table. moins statique, mais quand même ... J'utilise C # pour beaucoup de codage PIC et utilise beaucoup 0b101010 dans Hi-Tech C

--sample from code outpt--

 static class BinaryTable { const char nb00000000=0; const char nb00000001=1; const char nb00000010=2; const char nb00000011=3; const char nb00000100=4; //etc, etc, etc, etc, etc, etc, etc, } 

🙂 NEAL

Bien qu’il ne soit pas possible d’utiliser un littéral, peut-être qu’un BitConverter peut également être une solution?

La fonctionnalité littérale binary n’a pas été implémentée dans C # 6.0 et Visual Studio 2015. Mais le 30 mars 2016, Microsoft a annoncé la nouvelle version de Visual Studio ’15’ Preview avec laquelle nous pouvons utiliser des littéraux binarys.

Nous pouvons utiliser un ou plusieurs caractères Underscore (_) pour les séparateurs de chiffres. donc l’extrait de code ressemblerait à quelque chose comme:

 int x = 0b10___10_0__________________00; //binary value of 80 int SeventyFive = 0B100_________1011; //binary value of 75 WriteLine($" {x} \n {SeventyFive}"); 

et nous pouvons utiliser soit 0b et 0B comme indiqué dans l’extrait de code ci-dessus.

si vous ne voulez pas utiliser le séparateur de chiffres, vous pouvez l’utiliser sans séparateur de chiffres, comme ci-dessous l’extrait de code

 int x = 0b1010000; //binary value of 80 int SeventyFive = 0B1001011; //binary value of 75 WriteLine($" {x} \n {SeventyFive}"); 

Bien que la solution d’parsing de chaînes soit la plus populaire, je ne l’aime pas, car l’parsing des chaînes peut être très efficace dans certaines situations.

Quand il faut une sorte de masque binary ou bitfield, je préfère l’écrire comme

long bitMask = 1011001;

Et ensuite

int bit5 = BitField.GetBit (bitMask, 5);

Ou

bool flag5 = BitField.GetFlag (bitMask, 5); `

Où la classe BitField est

 public static class BitField { public static int GetBit(int bitField, int index) { return (bitField / (int)Math.Pow(10, index)) % 10; } public static bool GetFlag(int bitField, int index) { return GetBit(bitField, index) == 1; } } 

Fondamentalement, je pense que la réponse est NON, il n’y a pas de moyen facile. Utilisez des constantes décimales ou hexadécimales – elles sont simples et claires. La réponse de @RoyTinkers est également bonne – utilisez un commentaire.

 int someHexFlag = 0x010; // 000000010000 int someDecFlag = 8; // 000000001000 

Les autres réponses ici présentent plusieurs travaux utiles, mais je pense qu’ils ne sont pas meilleurs que la réponse simple. Les concepteurs de langage C # ont probablement considéré un préfixe «0b» inutile. HEX est facile à convertir en binary, et la plupart des programmeurs devront de toute façon connaître les équivalents DEC de 0-8.

En outre, lors de l’examen des valeurs dans le débogueur, elles seront affichées avec HEX ou DEC.

Vous pouvez utiliser 0b000001 depuis Visual Studio 2017 (C # 7.0)