title: UDP data transmission slower than TCP
body: <p>I'm currently writing a prototype application in C#/.Net4 where i need to transfer an unknown amount of data. The data is read in from a text file and then serialized into a byte array.
  Now i need to implement both transmission methods, UDP and TCP. The transmission in both ways does work fine but i have some struggleing with UDP. I assumend that the transmission using UDP have to be much faster than using TCP but in fact my tests proved that the UDP transmission is about 7 to 8 times slower than using TCP.
  I tested the transmission with a 12 megabyte file and the TCP transmission took about 1 second whereas the UDP transmission took about 7 seconds.
  In the application i use simple sockets to transmit the data. Since UDP does only allow a maximum of 65535kb per message, i splitted the serialized the byte array of the file into several parts where each part has the size of the socker SendBufferSize and then i transfer each part using Socket.Send() method call.</p>
  
  <p>Here is the code for the Sender part.</p>
  
  <pre><code>while (startOffset &lt; data.Length)
  {
      if ((startOffset + payloadSize) &gt; data.Length)
      {
          payloadSize = data.Length - startOffset;
      }
      byte[] subMessageBytes = new byte[payloadSize + 16];
      byte[] messagePrefix = new UdpMessagePrefix(data.Length, payloadSize, messageCount, messageId).ToByteArray();
      Buffer.BlockCopy(messagePrefix, 0, subMessageBytes, 0, 16);
      Buffer.BlockCopy(data, startOffset, subMessageBytes, messageOffset, payloadSize);
      messageId++;
      startOffset += payloadSize;
      udpClient.Send(subMessageBytes, subMessageBytes.Length);
      messages.Add(subMessageBytes);
  }
  </code></pre>
  
  <p>This code does simply copy the next part to be send into an byte array and then call the send method on the socket. My first guess was, that the splitting/copying of the byte arrays was slowing down the performance, but i isolated and tested the splitting code and the splitting took only a few milliseconds, so that was not causing the problem.</p>
  
  <pre><code>int receivedMessageCount = 1;
  Dictionary&lt;int, byte[]&gt; receivedMessages = new Dictionary&lt;int, byte[]&gt;();
  while (receivedMessageCount != totalMessageCount)
  {
      byte[] data = udpClient.Receive(ref remoteIpEndPoint);
      UdpMessagePrefix p = UdpMessagePrefix.FromByteArray(data);
      receivedMessages.Add(p.MessageId, data);
      //Console.WriteLine("Received packet: " + receivedMessageCount + " (ID: " + p.MessageId + ")");
      receivedMessageCount++;
      //Console.WriteLine("ReceivedMessageCount: " + receivedMessageCount);
  }
  Console.WriteLine("Done...");
  return receivedMessages;
  </code></pre>
  
  <p>This is the server side code where i receive the UDP messages. Each message has some bytes as a prefix where the total number of messages is stored and the size. So i simply call socket.Receive in a loop until i received the amount of messages which were specified in the prefix.</p>
  
  <p>My assumption here is that i may have implemented the UDP transmission code not "efficiently" enough... Maybe one of you guys already sees a problem in the code snippets or have any other suggestion or hint for me why my UDP transmission is slower than TCP.</p>
  
  <p>thanks in advance!</p>