Ottieni un bit specifico da byte

Ho un byte, in particolare un byte da un array di byte che è arrivato tramite UDP inviato da un altro dispositivo. Questo byte memorizza lo stato di attivazione / disattivazione di 8 relè nel dispositivo.

Come ottengo il valore di un bit specifico in detto byte? Idealmente un metodo di estensione sarebbe il più elegante e restituire un bool avrebbe più senso per me.

public static bool GetBit(this byte b, int bitNumber)
{
    //black magic goes here
}

Facile. Usa un AND bit per bit per confrontare il tuo numero con il valore 2 ^ bitNumber, che può essere calcolato a buon mercato spostando il bit.

//your black magic
var bit = (b & (1 << bitNumber-1)) != 0;

EDIT: Per aggiungere un po 'più di dettagli perché ci sono molte risposte simili senza spiegazione:

Un AND bit per bit confronta ogni numero, bit per bit, utilizzando un join AND per produrre un numero che è la combinazione di bit in cui sono stati impostati sia il primo che il secondo bit in quella posizione. Ecco la matrice logica della logica AND in un "nibble" che mostra il funzionamento di un AND bit per bit:

  0101
& 0011
  ----
  0001 //Only the last bit is set, because only the last bit of both summands were set

Nel tuo caso, confrontiamo il numero che hai passato con un numero che ha solo il bit che vuoi cercare impostato. Diciamo che stai cercando il quarto bit:

  11010010
& 00001000
  --------
  00000000 //== 0, so the bit is not set

  11011010
& 00001000
  --------
  00001000 //!= 0, so the bit is set

Lo spostamento di bit, per produrre il numero con cui vogliamo confrontare, è esattamente quello che sembra: prendi il numero, rappresentato come un insieme di bit, e sposta quei bit a sinistra oa destra di un certo numero di posizioni. Poiché questi sono numeri binari e quindi ogni bit è una maggiore potenza di due rispetto a quello alla sua destra, lo spostamento di bit a sinistra equivale a raddoppiare il numero una volta per ogni posizione che viene spostata, equivalente a moltiplicare il numero per 2 ^ x. Nel tuo esempio, cercando il quarto bit, eseguiamo:

       1 (2^0) << (4-1) ==        8 (2^3)
00000001       << (4-1) == 00001000

Ora sai come si fa, cosa sta succedendo a basso livello e perché funziona.

Sebbene sia utile leggere e comprendere la risposta di Josh, probabilmente sarai più felice di utilizzare la classe fornita da Microsoft per questo scopo: System.Collections.BitArray È disponibile in tutte le versioni di .NET Framework.

Questo

public static bool GetBit(this byte b, int bitNumber) {
   return (b & (1 << bitNumber)) != 0;
}

dovrebbe farlo, credo.

un altro modo per farlo :)

return ((b >> bitNumber) & 1) != 0;

Questo funziona più velocemente di 0,1 millisecondi.

return (b >> bitNumber) & 1;

Utilizzando la classe BitArray e creando un metodo di estensione come suggerito da OP:

public static bool GetBit(this byte b, int bitNumber)
{
    System.Collections.BitArray ba = new BitArray(new byte[]{b});
    return ba.Get(bitNumber);
}

prova questo:

return (b & (1 << bitNumber))>0;

Il metodo consiste nell'usare un altro byte insieme a un AND bit per bit per mascherare il bit di destinazione.

Ho usato le convenzioni delle mie classi qui dove "0" è il bit più significativo e "7" è il minimo.

public static class ByteExtensions
{
    // Assume 0 is the MSB andd 7 is the LSB.
    public static bool GetBit(this byte byt, int index)
    {
        if (index < 0 || index > 7)
            throw new ArgumentOutOfRangeException();

        int shift = 7 - index;

        // Get a single bit in the proper position.
        byte bitMask = (byte)(1 << shift);

        // Mask out the appropriate bit.
        byte masked = (byte)(byt & bitMask);

        // If masked != 0, then the masked out bit is 1.
        // Otherwise, masked will be 0.
        return masked != 0;
    }
}

Prova il codice qui sotto. La differenza con altri post è che puoi impostare / ottenere più bit usando una maschera ( field). La maschera per il 4 ° bit può essere, ad esempio, 1 << 3 o 0x10.

    public int SetBits(this int target, int field, bool value)
    {
        if (value) //set value
        {
            return target | field;
        }
        else //clear value
        {
            return target & (~field);
        }
    }

    public bool GetBits(this int target, int field)
    {
        return (target & field) > 0;
    }

** Esempio **

        bool is_ok = 0x01AF.GetBits(0x10); //false
        int res = 0x01AF.SetBits(0x10, true);
        is_ok = res.GetBits(0x10);  // true

[Flags]
enum Relays : byte
{
    relay0 = 1 << 0,
    relay1 = 1 << 1,
    relay2 = 1 << 2,
    relay3 = 1 << 3,
    relay4 = 1 << 4,
    relay5 = 1 << 5,
    relay6 = 1 << 6,
    relay7 = 1 << 7
}

public static bool GetRelay(byte b, Relays relay)
{
    return (Relays)b.HasFlag(relay);
}