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-loop：

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

你怎么看是否没有更多的对象？在我的例子中，我建议它以'\ 0'结尾。

祝你好运。

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

      }

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

2 个答案: