Saving a C Binary Tree

I have a threaded application handling numerous clients.  I have tried to pare down the code to a single OnDataReceived callback to illustrate what I am trying to do when a binary file transfer is received to simplify things for discussion.

private void OnDataReceived(IAsyncResult asyn)
{
    SocketPacket socketData = (SocketPacket)asyn.AsyncState;


    try
    {
        int iRx = 0;
        iRx = socketData.m_currentSocket.EndReceive(asyn);
        char[] chars = new char[iRx + 1];
        System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();


        int charLen = d.GetChars(socketData.dataBuffer,
            0, iRx, chars, 0);


        System.String szData = new System.String(chars);


        string strHeader = szData.Substring(0, 4);
        if (strHeader == "iFIL")  // Incoming Binary file;
        {
            // Add the data to the strFile variable Start position is +1 as header and
            // data are semi-colon seperated - iFIL;DATA_STRING
            string strFile = szData.Substring(5, szData.Length - 5);


            using (BinaryWriter b = new BinaryWriter(File.Open("test.bin", FileMode.Create)))
            {
                char[] c = strFile.ToCharArray();


                int length = c.Length;


                for (int count = 0; count < length; count++)
                {
                    b.Write(Convert.ToByte((c[count])));
                }
                b.Flush();
                b.Close();
            }
        }
    }
    catch (ObjectDisposedException)
    {
          System.Diagnostics.Debugger.Log(0, "1", "\nOnDataReceived: Socket has been closed\n");
    }
    catch (SocketException se)
    {
          MessageBox.Show(se.Message);
    }
}

using System;

using System.IO;

using System.Net;

using System.Net.Sockets;

using System.Threading;

using System.Text;

class Program

{

   static void Main()

   {

      new Thread(Server).Start();

      Thread.Sleep(500);

      Client();

   }

   static void Client()

   {       

      using (var client = new TcpClient("localhost", 50000)) // or whatever port you want to use

      {

         using (NetworkStream ns = client.GetStream())

         {

            using (var sw = new StreamWriter(ns)) // uses UTF8 by default

            {

               string s = "The quick brown fox jumped over the lazy dog";

               // make the stringto be sent 20 times longer

               string text = "";

               for (int i = 0; i < 20; i++)

               {

                 text += s + "\n"; // add Unix line end character

               }

               Console.WriteLine("Length of text sent is {0}\n", text.Length);                      

               sw.Write(text);

            }  

         }

      }

   }

   static void Server()

   {

      byte[] bytes = null;

      var listener = new TcpListener(IPAddress.Any, 50000);

      listener.Start();

      using (TcpClient client  = listener.AcceptTcpClient())

      {

          using (NetworkStream ns = client.GetStream())

          {

              byte[] buffer = new byte[256]; // use small buffer to test that the following works OK

              using (var ms = new MemoryStream())

              {

                 while (true)

                 {

                    int read = ns.Read (buffer, 0, buffer.Length);

                    if (read <= 0) break;

                    ms.Write (buffer, 0, read);

                 }

                  

                 bytes = ms.ToArray();

              } 

          }                    

      }

    

     listener.Stop();                   

     string text = Encoding.UTF8.GetString(bytes);

     Console.WriteLine("Length of text received is {0}\n", text.Length);  

     Console.WriteLine(text);

     Console.ReadKey();

  }

}

Unless you can ascertain otherwise, I wouldn't use a BinaryReader for this because it assumes that the stream is prefixed with the number of bytes sent which it may not be. I've therefore used the networkstream's Read() method which means that you have to implement some sort of buffering scheme, because you don't know how many bytes there are to read in the transmission.

Although I've converted the byte stream to a string here for illustration (using UTF-8), you shouldn't need to do that in your application.

Well, I'd assumed (perhaps wrongly) that Bert had already had to convert the string into an array of unsigned 16-bit integers and was now looking for an easy way to write that to a file. 

If the string had already contained the integers in binary form (with the bytes in the right order) and no other extraneous data, then he could simply have written the string to a file without further ado.  

If you could read the data into a char array, then you could write that to a file using the BinaryWriter.Write(char[]) method.

Although the char type is usually thought of as holding a single unicode character, it's effectively a 2 byte integer type that can hold values between 0 and 65,535 and you can cast between it and the normal integral types.