Konvertieren bool[] byte[]

Hier gibt ' s zwei Ansätze, je nachdem, ob Sie möchten, Verpacken Sie die bits in bytes, oder haben so viele bytes, wie original bit:

    bool[] bools = { true, false, true, false, false, true, false, true,
                     true };

    //basic - same count
    byte[] arr1 = Array.ConvertAll(bools, b => b ? (byte)1 : (byte)0);

    //pack (in this case, using the first bool as the lsb - if you want
    //the first bool as the msb, reverse things ;-p)
    int bytes = bools.Length / 8;
    if ((bools.Length % 8) != 0) bytes++;
    byte[] arr2 = new byte[bytes];
    int bitIndex = 0, byteIndex = 0;
    for (int i = 0; i < bools.Length; i++)
    {
        if (bools[i])
        {
            arr2[byteIndex] |= (byte)(((byte)1) << bitIndex);
        }
        bitIndex++;
        if (bitIndex == 8)
        {
            bitIndex = 0;
            byteIndex++;
        }
    }

Marc ' s Antwort ist gut, schon, aber...

Vorausgesetzt Sie sind die Art von person, die bequem ist zu tun-bit-twiddling, oder wollen einfach nur um weniger code zu schreiben und squeeze-out etwas mehr Leistung, dann ist dieser code hier ist für Sie, guter Herr /Frau:

byte[] PackBoolsInByteArray(bool[] bools)
{
    int len = bools.Length;
    int bytes = len >> 3;
    if ((len & 0x07) != 0) ++bytes;
    byte[] arr2 = new byte[bytes];
    for (int i = 0; i < bools.Length; i++)
    {
        if (bools[i])
            arr2[i >> 3] |= (byte)(1 << (i & 0x07));
    }
}

Tut es genau das gleiche wie Marc ' s code, es ist nur mehr lapidar.

Natürlich, wenn wir wirklich wollen, gehen alle aus wir ihn ausrollen zu...

...und wenn wir schon dabei sind, können Sie werfen eine Kurve ball auf den Rückgabetyp!

IEnumerable<byte> PackBoolsInByteEnumerable(bool[] bools)
{
    int len = bools.Length;
    int rem = len & 0x07; //hint: rem = len % 8.

    /*
    byte[] byteArr = rem == 0 //length is a multiple of 8? (no remainder?)
        ? new byte[len >> 3] //-yes-
        : new byte[(len >> 3)+ 1]; //-no-
     */

    const byte BZ = 0,
        B0 = 1 << 0, B1 = 1 << 1, B2 = 1 << 2, B3 = 1 << 3,
        B4 = 1 << 4, B5 = 1 << 5, B6 = 1 << 6, B7 = 1 << 7;

    byte b;
    int i = 0;
    for (int mul = len & ~0x07; i < mul; i += 8) //hint: len = mul + rem.
    {
        b = bools[i] ? B0 : BZ;
        if (bools[i + 1]) b |= B1;
        if (bools[i + 2]) b |= B2;
        if (bools[i + 3]) b |= B3;
        if (bools[i + 4]) b |= B4;
        if (bools[i + 5]) b |= B5;
        if (bools[i + 6]) b |= B6;
        if (bools[i + 7]) b |= B7;

        //byteArr[i >> 3] = b;
        yield return b;
    }

    if (rem != 0) //take care of the remainder...
    {
        b = bools[i] ? B0 : BZ; //(there is at least one more bool.)

        switch (rem) //rem is [1:7] (fall-through switch!)
        {
            case 7:
                if (bools[i + 6]) b |= B6;
                goto case 6;
            case 6:
                if (bools[i + 5]) b |= B5;
                goto case 5;
            case 5:
                if (bools[i + 4]) b |= B4;
                goto case 4;
            case 4:
                if (bools[i + 3]) b |= B3;
                goto case 3;
            case 3:
                if (bools[i + 2]) b |= B2;
                goto case 2;
            case 2:
                if (bools[i + 1]) b |= B1;
                break;
            //case 1 is the statement above the switch!
        }

        //byteArr[i >> 3] = b; //write the last byte to the array.
        yield return b; //yield the last byte.
    }

    //return byteArr;
}

Tipp: Wie Sie sehen können ist der code für die Rückgabe eines byte[] als Kommentare. Kommentieren Sie einfach die beiden yield-Anweisungen statt, wenn es das ist, was Sie wollen/brauchen.

Drehte Hinweise:

Verschiebung x >> 3 ist ein billiger x /8.

Maskierung x & 0x07 ist ein billiger x % 8.

Maskierung x & ~0x07 ist ein billiger x - x % 8.

Edit:
Hier finden Sie einige Beispiel-Dokumentation:

    ///<summary>
    ///Bit-packs an array of booleans into bytes, one bit per boolean.
    ///</summary><remarks>
    ///Booleans are bit-packed into bytes, in order, from least significant
    ///bit to most significant bit of each byte.<br/>
    ///If the length of the input array isn't a multiple of eight, then one
    ///or more of the most significant bits in the last byte returned will
    ///be unused. Unused bits are zero /unset.
    ///</remarks>
    ///<param name="bools">An array of booleans to pack into bytes.</param>
    ///<returns>
    ///An IEnumerable&lt;byte&gt; of bytes each containing (up to) eight
    ///bit-packed booleans.
    ///</returns>

Haben Sie einen Blick auf die BitConverter Klasse. Abhängig von der genauen Natur Ihrer Anforderung, es kann Ihr problem lösen ganz sauber.

Oder die IEnumerable Ansatz AnorZaken Antwort:

static IEnumerable<byte> PackBools(IEnumerable<bool> bools)
{
    int bitIndex = 0;
    byte currentByte = 0;
    foreach (bool val in bools) {
        if (val)
            currentByte |= (byte)(1 << bitIndex);
        if (++bitIndex == 8) {
            yield return currentByte;
            bitIndex = 0;
            currentByte = 0;
        }
    }
    if (bitIndex != 8) {
        yield return currentByte;
    }
}

Und die nach dem Auspacken, wo paddingEnd bedeutet, dass die Menge an bits zu verwerfen, aus dem letzten byte zu packen:

static IEnumerable<bool> UnpackBools(IEnumerable<byte> bytes, int paddingEnd = 0)
{
    using (var enumerator = bytes.GetEnumerator()) {
        bool last = !enumerator.MoveNext();
        while (!last) {
            byte current = enumerator.Current;
            last = !enumerator.MoveNext();
            for (int i = 0; i < 8 - (last ? paddingEnd : 0); i++) {
                yield return (current & (1 << i)) != 0;
            }
        }
    }
}