Converting from strings to byte arrays with LINQ in C# I'm taking in a string of input from the command line, and when prefixed by 0o or 8# interpreting it as an octal string. I'd like to convert it to a byte array more directly, but I'm not sure how to perform the bit carrying in LINQ.

All three of these methods are fully working; you can checkout the repository or just download the built executable and run it from the command line if need be.

I'd like a review of all three working methods, but more specifically I'd like to have the Octal method, below, not use a BitArray intermediary, similar to the Binary and Hex methods.

Here's how I'm doing it for hexadecimal (mostly LINQ):

public static byte[] GetHexBytes(this string hex, bool preTrimmed = false)
{
    if (!preTrimmed)
    {
        hex = hex.Trim();
        if (hex.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
            hex = hex.Substring(2);
        else if (hex.StartsWith("16#"))
            hex = hex.Substring(3);
    }

    if (hex.Length % 2 != 0) hex = hex.PadLeft(hex.Length + 1, '0');

    return Enumerable.Range(0, hex.Length)
            .Where(x =&gt; x % 2 == 0)
            .Select(x =&gt; Convert.ToByte(hex.Substring(x, 2), 16))
            .ToArray();
}


And here's binary (mostly LINQ):

public static byte[] GetBinaryBytes(this string binary, bool preTrimmed = false)
{
    if (!preTrimmed)
    {
        binary = binary.Trim();
        if (binary.StartsWith("0b", StringComparison.OrdinalIgnoreCase) || binary.StartsWith("2#"))
            binary = binary.Substring(2);
    }

    if (binary.Length % 8 != 0) binary = binary.PadLeft(binary.Length + 8 - binary.Length % 8, '0');

    return Enumerable.Range(0, binary.Length)
            .Where(x =&gt; x % 8 == 0)
            .Select(x =&gt; Convert.ToByte(binary.Substring(x, 8), 2))
            .ToArray();
}


And here's what I've got for Octal (LINQ, then a BitArray, then more LINQ):

public static byte[] GetOctalBytes(this string octal, bool preTrimmed = false)
{
    if (!preTrimmed)
    {
        octal = octal.Trim();
        if (octal.StartsWith("0o", StringComparison.OrdinalIgnoreCase) || octal.StartsWith("8#"))
            octal = octal.Substring(2);
    }

    octal = octal.TrimStart('0');
    if (octal.Length == 0)
        octal = "0";

    BitArray bits = new BitArray(octal
        .Reverse()
        .SelectMany(x =&gt;
            {
                byte value = (byte)(x - '0');
                return new bool[] { (value &amp; 0x01) == 1, (value &amp; 0x02) == 2, (value &amp; 0x04) == 4 };
            })
        .ToArray());

    byte[] bytes = new byte[bits.Length / 8 + 1];
    bits.CopyTo(bytes, 0);

    bytes = bytes.Reverse().SkipWhile(b =&gt; b == 0x00).ToArray();
    if (bytes.Length == 0)
        bytes = new byte[] { 0x00 };

    return bytes;
}


I don't like using the BitArray intermediary, but I don't know how to do it without it. If possible, I'd like the whole conversion in a single LINQ statement like the hex and binary.

This is part of a C# console application for computing hashes. Here's a link to the relevant source file on Github.
Edit: corrected an issue with leading zero bytes in the result.

I'll focus on the GetOctalBytes method in this review.

Also, for the explanation I assume that the string is processed right-to-left (reverse order) and similarily, the resulting byte array starts with the lowest byte at index 0. Those assumptions will be represented / corrected in the final code.

For octal strings, a group of 8 characters forms a group of up to 3 result bytes. So for each complete group, take 3 bytes. The following table shows important properties for different character counts of a group.

(in-group character count) (bits count) (bytes needed) (affected byte indices in group)
1                           3           1              0
2                           6           1              0
3                           9           2              0, 1
4                          12           2                 1
5                          15           2                 1
6                          18           3                 1, 2
7                          21           3                    2
8                          24           3                    2


The total bytes needed can be calculated as (octal.Length * 3 + 7) / 8. However, for length 3 or 6, the actually needed byte count can be lower, if the character value needs only 2 or 1 of its bits. So for these cases, the number of bytes can be lowered. Since a new group starts every 8 characters and each group needs 3 bytes, the starting index of the current byte group in the result array can be calculated as (character_index / 8) * 3. The affected in-group indices are calculated from the remainder:

remainder = (character_index % 8);
if (remainder &lt; 3) group-index 0 affected
if (remainder &gt;= 2 &amp;&amp; remainder &lt; 6) group-index 1 affected
if (remainder &gt;= 5) group-index 2 affected


In order to avoid leading zero bytes, the character value has to be considered additionally for the second and third byte.

I hope these explanations are enough introduction for the following code suggestion:

Note: I ditched the linq solution in favor of a more readable solution with less array-recreation.

public static byte[] GetOctalBytes(this string octal, bool preTrimmed = false)
{
    if (!preTrimmed)
    {
        octal = octal.Trim();
        if (octal.StartsWith("0o", StringComparison.OrdinalIgnoreCase) || octal.StartsWith("8#"))
            octal = octal.Substring(2);
    }

    octal = octal.TrimStart('0');
    if (octal.Length == 0)
        return new byte[] { 0 };

    var arrayLength = (octal.Length * 3 + 7) / 8;
    var inGroup = (octal.Length % 8);
    if ((inGroup == 3 &amp;&amp; octal[0] &lt; '4') ||
        (inGroup == 6 &amp;&amp; octal[0] &lt; '2'))
    {
        --arrayLength;
    }

    var result = new byte[arrayLength];

    for (int i = 0; i &lt; octal.Length; i++)
    {
        var baseIndex = (i / 8) * 3;
        var shift = (i % 8) * 3;
        var valueInGroup = (octal[octal.Length - i - 1] - '0') &lt;&lt; shift;

        result[result.Length - baseIndex - 1] |= (byte)(valueInGroup &amp; 0xff);
        if (valueInGroup &gt; 0xff)
            result[result.Length - baseIndex - 2] |= (byte)((valueInGroup &gt;&gt; 8) &amp; 0xff);
        if (valueInGroup &gt; 0xffff)
            result[result.Length - baseIndex - 3] |= (byte)((valueInGroup &gt;&gt; 16) &amp; 0xff);
    }

    return result;
}