(How)
C^# You Are - 3 February 2008

This week's questions revolve around streams and reading and writing them.

1. You need to read a file of integers into memory.  What is the easiest approach?  Answer

   The best approach is to create a BinaryReader to wrap the stream. You can then use the ReadInt32 method to read the integers one at a time. You can use any of the other methods to read other data types.

   public void ReadData ( Stream stream )
   {
      using(BinaryReader reader = new BinaryReader(stream))
      {
         int value = reader.ReadInt32();
      };
   }

2. You need to read a file of integers into memory.  Before you process the data you need to do a checksum comparison to ensure the data is valid.  After it is validated (by calculating the checksum against the read data) you need to convert the array of bytes to integers.  How do you do it?  Answer

   Thi is a little more complicated because you need to read the data into memory before processing it. Since you are dealing with binary data you should read the data into a byte array and then perform the checksum calculation. Once you have verified the data you need to convert it. To convert the data use BitConverter which is designed to convert to and from byte arrays.

   void ReadData ( Stream stream )
   {
      byte[] data = ...;
      stream.Read(data, 0, data.Length);
   
      //Do calculation
   
      //Convert
      for (int nIdx = 0; nIdx < data.Length; nIdx + 4)
      {
         int value = BitConverter.ToInt32(data, nIdx);
      };
   }

3. How do you read a string from a stream?  Answer

   Strings are problematic because they can be stored in different ways. They can be length prefixed, fixed size or null terminated.

   For length prefixed strings use the standard BinaryReader.ReadString method.

   For fixed size buffers read the entire data into memory (or even as blocks) using BinaryReader.Read. After the string is in memory then convert it using Encoding.CharSet.GetString. The CharSet used will depending upon how the string was saved (Unicode or ANSI). For fixed length strings there are probably padding characters added to it so use String.TrimEnd to remove them.

   For null terminated strings there is little option but to read the data one byte at a time, storing each byte into a byte array until you reach a null. Then convert as though it was a normal string. Note for Unicode strings that you should look for two nulls.

   string ReadBasicString ( BinaryReader reader )
   {
     &nbps;return reader.ReadString();
   }
   
   string ReadCStyleFixedSizeString ( BinaryReader reader, int size )
   {
      byte[] buffer = new byte[size];
      reader.Read(buffer, 0, size);
   
      string value = Encoding.ASCII.GetString(buffer, 0);
      value = value.TrimEnd('\0');
   
      return value;
   }
   
   string ReadNullTerminatedString ( BinaryReader reader )
   {
      int count = 0;
      byte[] buffer = new byte[1024]; //Could use a dynamic buffer here but we'll keep it simple
      byte value;
      do
      {
         value = (byte)reader.ReadByte();
         if (value != 0)
         buffer[count++] = value;
      } while (value != 0)
   
      return Encoding.ASCII.GetString(buffer, 0);
   }

4. How do you write a fixed size string to a stream?  Answer

   You first need to pad the string. We'll use nulls. To pad a string use String.PadRight. After the string is padded use Encoding.CharSet.GetBytes to get the byte array to write.

   void WriteFixedString ( BinaryWriter writer, string value, int size )
   {
      if (value.Length < size)
         value = value.PadRight('\0');
   
      byte[] buffer = Encoding.ASCII.GetBytes(value);
      writer.Write(buffer);
   }

5. How do you write a structure to a stream?  Answer

   Unfortunately there is no easy way to do this. You could try marshalling the data using the Marshal class but the performance and memory will probably be too much. Instead it is generally best to write custom read/write code to read and write each structure field from/to the stream.