Holen Sie sich ein bestimmtes Bit aus Byte

Ich habe ein Byte, speziell ein Byte aus einem Byte-Array, das über UDP eingegangen ist und von einem anderen Gerät gesendet wurde. Dieses Byte speichert den Ein / Aus-Zustand von 8 Relais im Gerät.

Wie erhalte ich den Wert eines bestimmten Bits in diesem Byte? Im Idealfall würde eine Erweiterungsmethode am elegantesten aussehen, und die Rückgabe eines Bools wäre für mich am sinnvollsten.

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

Einfach. Verwenden Sie ein bitweises UND, um Ihre Zahl mit dem Wert 2 ^ bitNumber zu vergleichen, der durch Bitverschiebung kostengünstig berechnet werden kann.

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

EDIT: Um ein wenig mehr Details hinzuzufügen, da es viele ähnliche Antworten ohne Erklärung gibt:

Ein bitweises UND vergleicht jede Zahl bitweise mit einem UND-Join, um eine Zahl zu erzeugen, die die Kombination von Bits darstellt, bei denen sowohl das erste Bit als auch das zweite Bit an dieser Stelle gesetzt wurden. Hier ist die Logikmatrix der UND-Logik in einem "Halbbyte", die die Funktionsweise eines bitweisen UND zeigt:

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

In Ihrem Fall vergleichen wir die übergebene Nummer mit einer Nummer, die nur das Bit enthält, nach dem Sie suchen möchten. Angenommen, Sie suchen nach dem vierten Bit:

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

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

Bitverschiebung, um die Zahl zu erzeugen, mit der wir vergleichen möchten, ist genau das, wonach es sich anhört: Nehmen Sie die Zahl, die als Satz von Bits dargestellt wird, und verschieben Sie diese Bits um eine bestimmte Anzahl von Stellen nach links oder rechts. Da es sich um Binärzahlen handelt und jedes Bit eine größere Zweierpotenz als das rechts davon ist, entspricht eine Bitverschiebung nach links einer einmaligen Verdoppelung der Zahl für jede verschobene Stelle, was einer Multiplikation der Zahl mit entspricht 2 ^ x. In Ihrem Beispiel suchen wir nach dem vierten Bit:

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

Jetzt wissen Sie, wie es gemacht wird, was auf niedriger Ebene vor sich geht und warum es funktioniert.

Es ist zwar gut, Joshs Antwort zu lesen und zu verstehen, aber Sie werden wahrscheinlich glücklicher sein, wenn Sie die von Microsoft für diesen Zweck bereitgestellte Klasse verwenden: System.Collections.BitArray Sie ist in allen Versionen von .NET Framework verfügbar.

Dies

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

sollte es tun, denke ich.

eine andere Art es zu tun :)

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

Dies funktioniert schneller als 0,1 Millisekunden.

return (b >> bitNumber) & 1;

Die Verwendung der BitArray- Klasse und das Erstellen einer Erweiterungsmethode als OP schlägt vor:

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

Versuche dies:

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

Die Methode besteht darin, ein anderes Byte zusammen mit einem bitweisen UND zu verwenden, um das Zielbit auszublenden.

Ich habe hier Konventionen aus meinen Klassen verwendet, wobei "0" das höchstwertige Bit und "7" das niedrigste ist.

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;
    }
}

Versuchen Sie den folgenden Code. Der Unterschied zu anderen Posts besteht darin, dass Sie mit einer Maske ( field) mehrere Bits setzen / abrufen können . Die Maske für das 4. Bit kann beispielsweise 1 << 3 oder 0x10 sein.

    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;
    }

** Beispiel **

        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);
}