c# 字节数组中的左移半字节

Question

这是我的功能的要求：

取以下字符串：

6900460420006149231=13050010300100000

并将其转换为以下字节数组：

{ 0x37, 0x06, 0x90, 0x04, 0x60, 0x42, 0x00, 0x06, 0x14, 0x92, 0x31, 0xD1, 0x30, 0x50, 0x01, 0x03, 0x00, 0x10, 0x00, 0x00 }

第一个字节 0x37 是二进制字符串的原始长度。接下来的 10 个字节是以 bcd 格式编码的字符串“6900460420006149231”。这就是棘手的地方。现在我需要十六进制“D”来表示两个字段之间的分隔符（=）。您可以在字节数组中的 12 索引的高半字节中看到十六进制。字节数组的其余部分是以 bcd 格式编码的第二个字段“13050010300100000”。如果原始长度是奇数，我会在未使用数据的前半字节填充前导零。

我不希望任何人都能全面实施，所以让我们分解一下并解决我遇到问题的地方。 假设我有：

byte[] field1Bytes = { 0x06, 0x90, 0x04, 0x60, 0x42, 0x00, 0x06, 0x14, 0x92, 0x31 }
byte[] field2Bytes = { 0x01, 0x30, 0x50, 0x01, 0x03, 0x00, 0x10, 0x00, 0x00 }
byte separator = 13; // D  0x0D

如果我只是使用 Array.Copy，我最终会得到：

{ 0x06, 0x90, 0x04, 0x60, 0x42, 0x00, 0x06, 0x14, 0x92, 0x31, 0x0D, 0x01, 0x30, 0x50, 0x01, 0x03, 0x00, 0x10, 0x00, 0x00 }

上面的字节数组并不是我所需要的。关于如何实现以下函数以使我更接近我想要实现的目标的任何想法：

byte[] ShiftLeftAndCombine(byte[] b1, byte[] b2)

在哪里

ShiftLeftAndCombine({0x0d}, {0x01, 0x30})

会返回

{0xd1, 0x30}

• 在旁注中，我意识到我需要处理偶数/奇数字段长度来处理我正在编写的实际函数，但让我担心 =]

Answer 1

在我看来，您真正需要做的是将整个第二块内存左移四位。这意味着您要做的不仅仅是复制，您还将把字节 n+1 的“前导”（最高有效）位移动到“尾随”（最低有效）第 n 个字节。这是字节数组的通用“位移器”。

    byte[] shiftBlock(byte[] bytes, short bitShift)
    {
        byte[] newBytes = new byte[bytes.Length+1];
        for (int index=0;index < bytes.Length; index++)
        {
            // Each new byte is the current byte shifted left by "bitShift" bits,
            // followed by the first 8-bitShift bits of the next byte OR zero,
            // if we're at the end of the array. Shift the next-bytes bits to
            // the right, and OR the result together. 

            byte newByteMSB = (byte)(bytes[index] << bitShift); // shift left bitShift bits
            byte newByteLSB = (byte)((index==bytes.Length-1)?((byte)0):(bytes[index+1]));
            newByteLSB = (byte) (newByteLSB >> (8-bitShift));

            newBytes[index] = (byte) ( newByteMSB | newByteLSB);

        }

        return newBytes;
    }

您应该能够将其调整为具有必要注意事项的更广泛的解决方案。我对它进行了粗略的测试，它似乎适用于我扔给它的简单字节数组。希望这会有所帮助！

Answer 2

不确定这是否是作业，但左移和组合部分看起来像这样：

var pos = 0;
var newByte = b1[pos] << 4;
newByte |= b2[pos]

显然，您需要在循环中执行此操作并考虑 2 个数组的长度

Answer 3

我会做一个 BCD 类。然后 BCD.ToByteArray() 会以 Byte[] 格式为您提供 BCD 的当前表示，而 BCD.ToString() 将提供字符串格式。在内部将 BCD 存储为每个 BCD 位一个数组元素。如果你设计自己的数据结构而不是试图让 Byte[] 做它不打算做的事情，你会做得更好。

Answer 4

好的，我明白了：

    static void Main(string[] args)
    {
        const string rawTrack = "6900460420006149231=13050010300100000";

        var byteList = new LinkedList<byte>();

        foreach (var c in rawTrack)
        {
            if(c.Equals('='))
            {
                byteList.AddLast(13);
                continue;
            }

            var bytes = Formatters.Bcd.GetBytes(new string(c, 1));  // for 9 gives 0x09
            byteList.AddLast(bytes[0]);
        }

        // Adjust Buffer if odd length
        if(rawTrack.Length % 2 != 0)
        {
            byteList.AddFirst(0);
        }

        var result = new byte[byteList.Count / 2];
        var buffer = new byte[byteList.Count];
        byteList.CopyTo(buffer, 0);

        var j = 0;
        for(var i = 0; i < buffer.Length - 1; i += 2, j++ )
        {
            result[j] = CombineLowNibble(buffer[i], buffer[i + 1]);
        }


        Console.WriteLine(BitConverter.ToString(result));
    }

    private static byte CombineLowNibble(byte b, byte b1)
    {
        return (byte) ((b << 4) | b1);
    }

结果如下：

06-90-04-60-42-00-06-14-92-31-D1-30-50-01-03-00-10-00-00

Answer 5

编辑：修改为在结果中不包括原始长度。

希望这会有所帮助。不过，不确定您是如何计算出原始长度为 0x37 的。 :)

根据所述的预期结果，您只需将分隔符 nybble 移到第二个数组的第一个字节中。

byte[] field1Bytes = { 0x06, 0x90, 0x04, 0x60, 0x42, 0x00, 0x06, 0x14, 0x92, 0x31 } ;
byte[] field2Bytes = { 0x01, 0x30, 0x50, 0x01, 0x03, 0x00, 0x10, 0x00, 0x00 } ;
byte separator = 13; // D  0x0D 

byte[] result = new byte[field1Bytes.Length + field2Bytes.Length];


Array.Copy(field1Bytes, 0, result, 0, field1Bytes.Length);
Array.Copy(field2Bytes, 0, result, field1Bytes.Length, field2Bytes.Length);

// shift the separator into the first byte of the second array in the result
result[field1Bytes.Length] |= (byte)(separator << 4);

这会产生：

0x06 0x90 0x04 0x60 0x42 0x00 0x06 0x14 0x92 0x31 0xd1 0x30 0x50 0x01 0x03 0x00 0x10 0x00 0x00

...与规定的期望结果相匹配。