解析包含不同类型数据的字节数组

Question

我有一个固定长度的字节数组，长度为 1250 字节。它可能包含以下类型的数据：

• 对象A由5个字节组成。第一个字节包含 字母“A”和接下来的四个字节存储 1 - 100000 之间的整数。

• 对象B由2个字节组成。第一个字节包含字母“B”，下一个字节包含 1 - 100 之间的整数。

• 对象C由50个字节组成。所有 50 个字节用于存储 ASCII 编码的字符串，该字符串仅由数字和以下字符组成：- + ( 和 )

我不知道字节数组中有多少每种对象类型，但我知道它们被分组在一起（对象 B、对象 B、对象 A、对象 A、对象 A、对象 C 等）。大多数时候，当我解析字节数组时，该数组包含一种类型的数据（例如，所有项目都是对象 A），因此我确切地知道每个项目由多少个字节组成，并且我只需循环处理该字节的数组。在本例中，我有三种不同类型的数据，它们的长度都不同。我在想我需要做这样的事情：

int offset = 0;
while (offset <= 1250)
{
    string objectHeader = Encoding.ASCII.GetString(byteArray, offset, 1);

    if (objectHeader.Equals("A"))
    {
        // read 4 more bytes and then convert into int value (1 - 100000)
        index += 5;
    }
    else if (objectHeader.Equals("B"))
    {
        // read 1 more byte and then convert into int value (1 - 100)
        index += 2;
    }
    else
    {
        // read 49 more bytes and then convert into a string
        index += 50;
    }
}

有更好的方法吗？

Answer 1

嗯，偏移量和索引似乎有点混乱，也许你应该使用 for 循环：

for(int index = 0; index < 1250; index++)
{
    switch(byteArray[index])
    {
         case (byte)'A':
             index++;
             int value = BitConverter.ToInt32(byteArray, index);
             index += 4;
             break;

       case (byte)'B':
             index++;
             // Read the next byte as integer.
             int value = (int)byteArray[index];
             index++;
             break;

       case (byte)'C':  // string.
             index++;
             // Read the next 49 bytes as an string.
             StringBuilder value = new StringBuilder(49);
             for(int i = index; i < index + 49; index++)
             {
                 if (byteArray[i] == 0) break;
                 value.Append(Converter.ToChar(byteArray[i]));
             }
             index+= 49;
             break;

       case 0:  // Finished.
             index = 1250;
             break;
       default:
             throw new InvalidArgumentException("Invalid byte array format");
    }
}

如何查看是否没有更多物体？在我的示例中，我建议它以“”结尾。

祝你的任务顺利。

Answer 2

      int offset = 0;
      while (offset <= 1250)
      {

        switch (byteArray[offset])
        {
          case (byte)'A':
            //read other data ..
            offset += 5;
            break;
          case (byte)'B':
            //read other data ..
            offset += 2;
            break;
          case (byte)'C':
            //read other data ..
            offset += 50;
            break;
          default:
            //error
            break;
        }
      } 

或者带有二进制阅读器的另一种变体：

      var reader = new BinaryReader(new MemoryStream(byteArray), Encoding.ASCII);
      while (reader.BaseStream.Position < reader.BaseStream.Length)
      {
        switch(reader.ReadChar())
        {
          case 'A':
            {
              var i = reader.ReadInt32();
              return new TypeA(i);
            }
            break;
          case 'B':
            {
              var i = reader.ReadByte();
              return new TypeB(i);
            }
            break;
          case 'C':
            {
              var chars = reader.ReadChars(49);
              return new TypeC(new string(chars.TakeWhile(ch => ch != 0).ToArray()));
            }
            break;
        }

      }

Answer 3

C 中曾经有一种方法可以创建一个结构体，然后将一个字节数组应用于该结构体布局......就像切饼干一样。我想知道这种能力是否仍然存在。