Remove obvious allocation from UdpClientConnection. How did I miss that?

diff --git a/Hazel/MessageReader.cs b/Hazel/MessageReader.cs
index b1eab3377edbcbafad25843454e21480550ee953..447c04d7dd721b000495a35072e13e3ac840e443 100644 (file)
--- a/Hazel/MessageReader.cs
+++ b/Hazel/MessageReader.cs
@@ -44,18 +44,6 @@ namespace Hazel
             return output;
         }
         
-        public static MessageReader GetRaw(byte[] bytes, int offset, int length)
-        {
-            var output = ReaderPool.GetObject();
-
-            output.Buffer = bytes;
-            output.Offset = offset;
-            output.Position = 0;
-            output.Length = length;
-            output.Tag = byte.MaxValue;
-            return output;
-        }
-
         public static MessageReader Get(byte[] buffer)
         {
             var output = ReaderPool.GetObject();

diff --git a/Hazel/Udp/UdpClientConnection.cs b/Hazel/Udp/UdpClientConnection.cs
index 7ce5dbc23d1c6cd3976fb0298ec64325406b9e7d..ee678fbbfc35b7f72f0662974848ca0797e90499 100644 (file)
--- a/Hazel/Udp/UdpClientConnection.cs
+++ b/Hazel/Udp/UdpClientConnection.cs
@@ -20,11 +20,6 @@ namespace Hazel.Udp
         /// </summary>
         private Socket socket;
 
-        /// <summary>
-        ///     The buffer to store incomming data in.
-        /// </summary>
-        private byte[] dataBuffer = new byte[ushort.MaxValue];
-
         private Timer reliablePacketTimer;
 
         /// <summary>
@@ -77,7 +72,7 @@ namespace Hazel.Udp
         }
 
         public event Action<byte[], int> DataSentRaw;
-        public event Action<byte[]> DataReceivedRaw;
+        public event Action<byte[], int> DataReceivedRaw;
 
         private void WriteBytesToConnectionReal(byte[] bytes, int length)
         {
@@ -97,6 +92,7 @@ namespace Hazel.Udp
                         {
                             socket.EndSendTo(result);
                         }
+                        catch (NullReferenceException) { }
                         catch (ObjectDisposedException)
                         {
                             Disconnect("Could not send as the socket was disposed of.");
@@ -208,7 +204,15 @@ namespace Hazel.Udp
         /// </summary>
         void StartListeningForData()
         {
-            socket.BeginReceive(dataBuffer, 0, dataBuffer.Length, SocketFlags.None, ReadCallback, dataBuffer);
+            var msg = MessageReader.GetSized(ushort.MaxValue);
+            try
+            {
+                socket.BeginReceive(msg.Buffer, 0, msg.Buffer.Length, SocketFlags.None, ReadCallback, msg);
+            }
+            catch
+            {
+                msg.Recycle();
+            }
         }
 
         /// <summary>
@@ -217,35 +221,37 @@ namespace Hazel.Udp
         /// <param name="result">The asyncronous operation's result.</param>
         void ReadCallback(IAsyncResult result)
         {
-            int bytesReceived;
+            var msg = (MessageReader)result.AsyncState;
 
-            //End the receive operation
             try
             {
-                bytesReceived = socket.EndReceive(result);
+                msg.Length = socket.EndReceive(result);
+            }
+            catch (NullReferenceException)
+            {
+                msg.Recycle();
+                return;
             }
             catch (ObjectDisposedException)
             {
-                //If the socket's been disposed then we can just end there.
+                msg.Recycle();
                 return;
             }
             catch (SocketException e)
             {
+                msg.Recycle();
                 Disconnect("Socket exception while reading data: " + e.Message);
                 return;
             }
 
             //Exit if no bytes read, we've failed.
-            if (bytesReceived == 0)
+            if (msg.Length == 0)
             {
+                msg.Recycle();
                 Disconnect("Received 0 bytes");
                 return;
             }
 
-            //Copy data to new array
-            byte[] bytes = new byte[bytesReceived];
-            Buffer.BlockCopy(dataBuffer, 0, bytes, 0, bytesReceived);
-
             //Begin receiving again
             try
             {
@@ -274,9 +280,8 @@ namespace Hazel.Udp
                 }
             }
 
-            DataReceivedRaw?.Invoke(bytes);
-            MessageReader msg = MessageReader.GetRaw(bytes, 0, bytesReceived);
-            HandleReceive(msg, bytesReceived);
+            DataReceivedRaw?.Invoke(msg.Buffer, msg.Length);
+            HandleReceive(msg, msg.Length);
         }
 
         /// <summary>