Comment grignoter (nybble) des octets en C# ?

Question

Je cherche à apprendre comment obtenir deux quarts (haut et bas) d'un octet en utilisant C# et comment assembler deux quarts en retour à un octet.

J'utilise C# et .Net 4.0 si cela peut aider à déterminer quelles méthodes peuvent être utilisées et quelles bibliothèques peuvent être disponibles.

Answer 1

Vous pouvez "masquer" 4 bits d'un octet pour obtenir un bit, puis décaler ces bits vers la position la plus à droite de l'octet :

byte x = 0xA7;  // For example...
byte nibble1 = (byte) (x & 0x0F);
byte nibble2 = (byte)((x & 0xF0) >> 4);
// Or alternatively...
nibble2 = (byte)((x >> 4) & 0x0F);
byte original = (byte)((nibble2 << 4) | nibble1);

Answer 2

Cette extension fait ce que l'OP a demandé, j'ai pensé pourquoi ne pas la partager :

/// <summary>
/// Extracts a nibble from a large number.
/// </summary>
/// <typeparam name="T">Any integer type.</typeparam>
/// <param name="t">The value to extract nibble from.</param>
/// <param name="nibblePos">The nibble to check,
/// where 0 is the least significant nibble.</param>
/// <returns>The extracted nibble.</returns>
public static byte GetNibble<T>(this T t, int nibblePos)
 where T : struct, IConvertible
{
 nibblePos *= 4;
 var value = t.ToInt64(CultureInfo.CurrentCulture);
 return (byte)((value >> nibblePos) & 0xF);
}

Answer 3

Aucune des réponses n'étant satisfaisante, je vais soumettre la mienne. Mon interprétation de la question était :
Entrée : 1 octet (8 bits)
Sortie : 2 octets, chacun stockant un bit, ce qui signifie que les 4 bits les plus à gauche (le bit le plus haut) sont 0000 tandis que les 4 bits les plus à droite (le bit le plus bas) contiennent le bit séparé.

byte x = 0x12; //hexadecimal notation for decimal 18 or binary 0001 0010
byte highNibble = (byte)(x >> 4 & 0xF); // = 0000 0001
byte lowNibble = (byte)(x & 0xF); // = 0000 0010

Answer 4

Je suppose que vous pouvez faire des opérations sur les bits.

byte nib = 163; //the byte to split
byte niblow = nib & 15; //bitwise AND of nib and 0000 1111
byte nibhigh = nib & 240; //bitwise AND of nib and 1111 0000
Assert.IsTrue(nib == (nibhigh | niblow)); //bitwise OR of nibhigh and niblow equals the original nib.