Question

I am reading a binary log file produced by a piece of equipment.

I have the data in a byte[].

If I need to read two bytes to create a short I can do something like this:

short value = (short)(byte[1] << 8); value += byte[2]; 

Now I know the value is the correct for valid data.

How would I know if the file was messed up and lets say the values FF FF were in those two places in the byte array?

When I look at the resultant value of converting FF FF to a short, I get a -1.

Is this a normal value for FF FF?, or did the computer just hit some kind of short bound and roll over with invalid data?

For my purposes all of theses numbers are going to be positive. If FF FF is actually a short -1, then I just need to validate that all my results are postitive.

Thank you,
Keith

BTW, I am also reading other number data types. I’ll show them here just because. The Read function is the basic part of reading from the byte[]. All the other data type reads use the basic Read() function.

    public byte Read()     {         //advance position and then return byte at position           byte returnValue;         if (_CurrentPosition < _count - 1)         {             returnValue= _array[_offset + ++_CurrentPosition];             return returnValue;         }         else             throw new System.IO.EndOfStreamException                    ('Cannot Read Array, at end of stream.');      }       public float ReadFloat()     {         byte[] floatTemp = new byte[4];         for (int i = 3; i >= 0; i--)         {             floatTemp[i] = Read();         }          float returnValue = System.BitConverter.ToSingle             (floatTemp, 0);          if (float.IsNaN(returnValue))         {             throw new Execption('Not a Number');             }         return returnValue;     }       public short ReadInt16()     {         short returnValue = (short)(Read() << 8);         returnValue += Read();         return returnValue;     }      public int ReadInt32()     {         int returnValue = Read() << 24;         returnValue += Read() << 16;         returnValue += Read() << 8;         returnValue += Read();         return returnValue;     } 

Answer 1

0xffff (all bits equal to 1) is -1 for signed shorts, yes. Read up on Two’s complement to learn more about the details. You can switch to a larger datatype, or (as suggested by Grzenio) just use an unsigned type.