the stress tests will never work properly with testing frameworks. we will bring back the test listener , but in the meantime i've fixed the problem with the messages

GuilhermeStrice · GuilhermeStrice · commit 7cbdeb99b654 · 2025-11-26T06:21:51.000Z
diff --git a/Infinity.Core/NetworkConnectionListener.cs b/Infinity.Core/NetworkConnectionListener.cs
@@ -2,7 +2,7 @@
 
 namespace Infinity.Core
 {
-    public delegate bool HandshakeCheck(IPEndPoint _endPoint, MessageReader _reader, out byte[] _response);
+    public delegate bool HandshakeCheck(IPEndPoint _endPoint, MessageReader _reader, out MessageWriter _response);
 
     public abstract class NetworkConnectionListener : IDisposable
     {
diff --git a/Infinity.Tests/Infinity.Udp.Tests/NoConnectionUdpConnection.cs b/Infinity.Tests/Infinity.Udp.Tests/NoConnectionUdpConnection.cs
@@ -37,7 +37,7 @@ public async Task Test_Receive(MessageWriter msg)
             await HandleReceive(data, data.Length);
         }
 
-        public override async Task WriteBytesToConnection(MessageWriter _writer)
+        public override async Task WriteBytesToConnection(MessageWriter _writer, bool _recycle_writer)
         {
             BytesSent.Add(MessageReader.Get(_writer.Buffer, 0, _writer.Length));
         }
diff --git a/Infinity.Tests/Infinity.Udp.Tests/StressTests.cs b/Infinity.Tests/Infinity.Udp.Tests/StressTests.cs
@@ -85,18 +85,18 @@ public async Task StressOpeningConnections()
         {
             Console.WriteLine("StressOpeningConnections");
 
-            int connections_to_test = 100;
+            int connections_to_test = 10;
             int port = Util.GetFreePort();
             var ep = new IPEndPoint(IPAddress.Loopback, port);
-            ConcurrentStack<UdpClientConnection> connections = new ConcurrentStack<UdpClientConnection>();
+            List<UdpClientConnection> connections = new List<UdpClientConnection>();
             int con_count = 0;
-            var allConnectedTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            ManualResetEvent mutex = new ManualResetEvent(false);
 
             using (var listener = new UdpConnectionListener(ep))
             {
                 listener.NewConnection += obj =>
                 {
-                    Interlocked.Increment(ref con_count);
+                    con_count++;
 
                     obj.Connection.DataReceived += data_args =>
                     {
@@ -109,17 +109,16 @@ public async Task StressOpeningConnections()
                     };
 
                     obj.Recycle();
-
+                    Console.WriteLine(con_count);
                     if (con_count == connections_to_test)
                     {
-                        allConnectedTcs.TrySetResult();
+                        mutex.Set();
                     }
                 };
 
                 listener.Start();
 
                 // Launch all client connections
-                var tasks = new List<Task>();
                 for (int i = 0; i < connections_to_test; i++)
                 {
                     var handshake = UdpMessageFactory.BuildHandshakeMessage();
@@ -129,16 +128,16 @@ public async Task StressOpeningConnections()
                     connection.DataReceived += data_args => data_args.Recycle();
                     connection.Disconnected += e => e.Recycle();
 
-                    tasks.Add(connection.Connect(handshake));
-                    connections.Push(connection);
+                    await connection.Connect(handshake);
+                    connections.Add(connection);
 
                     // same problem as with stress test reliable messages
-                    await Task.Delay(1);
+                    await Task.Delay(100);
                 }
 
                 // Wait for all clients to finish connecting
-                var completed = await Task.WhenAny(allConnectedTcs.Task, Task.Delay(10000));
-                Assert.True(allConnectedTcs.Task.IsCompleted, "Not all connections established in time.");
+                mutex.WaitOne(5000);
+                Assert.Equal(connections_to_test, con_count);
 
                 // Verify listener connection count
                 Assert.Equal(connections_to_test, listener.ConnectionCount);
@@ -164,15 +163,19 @@ public async Task StressReliableMessages()
 
             int count = 0;
 
-            int messages_to_try = 100;
+            int messages_to_try = 10000;
 
             var mutex = new ManualResetEvent(false);
 
+            UdpServerConnection server_connection = null;
+
             using (UdpConnectionListener listener = new UdpConnectionListener(ep))
             using (UdpConnection connection = new UdpClientConnection(new TestLogger("Client"), ep))
             {
                 listener.NewConnection += (evt) =>
                 {
+                    server_connection = (UdpServerConnection)evt.Connection;
+
                     evt.Connection.Disconnected += delegate (DisconnectedEvent obj)
                     {
                         obj.Recycle();
@@ -185,17 +188,6 @@ public async Task StressReliableMessages()
                         {
                             mutex.Set();
                             sw.Stop();
-                            Console.WriteLine("Readers: " + Core.Pools.ReaderPool.InUse.ToString());
-                            Console.WriteLine("Packets: " + Infinity.Udp.Pools.PacketPool.InUse.ToString());
-                            Console.WriteLine("Fragmented: " + Infinity.Udp.Pools.FragmentedMessagePool.InUse.ToString());
-                            Console.WriteLine("Writers: " + Core.Pools.WriterPool.InUse.ToString());
-
-                            Console.WriteLine("DataReceived: " + Core.Pools.DataReceivedEventPool.InUse.ToString());
-                            Console.WriteLine("Disconnected: " + Core.Pools.DisconnectedEventPool.InUse.ToString());
-                            Console.WriteLine("NewConnection: " + Core.Pools.NewConnectionPool.InUse.ToString());
-
-                            Console.WriteLine("Server packets: " + ((UdpConnection)(obj.Connection)).reliable_data_packets_sent.Count);
-                            Console.WriteLine("Client packets: " + ((UdpConnection)connection).reliable_data_packets_sent.Count);
                         }
                         obj.Recycle();
                     };
@@ -220,16 +212,28 @@ public async Task StressReliableMessages()
                     var message = UdpMessageFactory.BuildReliableMessage();
                     message.Write(123);
 
-                    _ = connection.Send(message);
+                    await connection.Send(message);
 
                     // if we dont have this delay something weird happens and the packets and readers are not recycled, need to figure stuff out
-                    await Task.Delay(1);
+                    //await Task.Delay(1);
                 }
 
-                mutex.WaitOne(2000);
+                mutex.WaitOne(10000);
                 Assert.Equal(messages_to_try, count);
-                await Task.Delay(1000);
+                await Task.Delay(10000);
                 Console.WriteLine($"StressReliableMessages took {sw.ElapsedMilliseconds}ms");
+
+                Console.WriteLine("Readers: " + Core.Pools.ReaderPool.InUse.ToString());
+                Console.WriteLine("Packets: " + Infinity.Udp.Pools.PacketPool.InUse.ToString());
+                Console.WriteLine("Fragmented: " + Infinity.Udp.Pools.FragmentedMessagePool.InUse.ToString());
+                Console.WriteLine("Writers: " + Core.Pools.WriterPool.InUse.ToString());
+
+                Console.WriteLine("DataReceived: " + Core.Pools.DataReceivedEventPool.InUse.ToString());
+                Console.WriteLine("Disconnected: " + Core.Pools.DisconnectedEventPool.InUse.ToString());
+                Console.WriteLine("NewConnection: " + Core.Pools.NewConnectionPool.InUse.ToString());
+
+                Console.WriteLine("Server packets: " + server_connection.reliable_data_packets_sent.Count);
+                Console.WriteLine("Client packets: " + ((UdpConnection)connection).reliable_data_packets_sent.Count);
             }
         }
 
diff --git a/Infinity.Tests/Infinity.Udp.Tests/UdpConnectionTests.cs b/Infinity.Tests/Infinity.Udp.Tests/UdpConnectionTests.cs
@@ -175,7 +175,7 @@ public async Task UdpHandshakeTest()
                 // Use TaskCompletionSource for async signaling
                 var tcs = new TaskCompletionSource();
 
-                listener.HandshakeConnection = (IPEndPoint endPoint, MessageReader input, out byte[] response) =>
+                listener.HandshakeConnection = (IPEndPoint endPoint, MessageReader input, out MessageWriter response) =>
                 {
                     response = null;
 
diff --git a/Infinity.Udp/Fragmented/UdpConnection.Fragmented.cs b/Infinity.Udp/Fragmented/UdpConnection.Fragmented.cs
@@ -40,6 +40,8 @@ private async Task FragmentedSend(MessageWriter _writer)
                 await Task.Delay(10);
             }
 
+            _writer.Recycle();
+
             if (last_fragment_id_allocated >= byte.MaxValue)
             {
                 Interlocked.Exchange(ref last_fragment_id_allocated, 0);
diff --git a/Infinity.Udp/Reliable/UdpConnection.Reliable.cs b/Infinity.Udp/Reliable/UdpConnection.Reliable.cs
@@ -35,9 +35,8 @@ internal async Task<int> ManageReliablePackets()
         protected async Task ReliableSend(MessageWriter _writer, Action _ack_callback = null)
         {
             AttachReliableID(_writer, 1, _ack_callback);
-            await WriteBytesToConnection(_writer).ConfigureAwait(false);
             Statistics.LogReliableMessageSent(_writer.Length);
-            _writer.Recycle();
+            await WriteBytesToConnection(_writer).ConfigureAwait(false);
         }
 
         private async Task ReliableMessageReceive(MessageReader _reader)
diff --git a/Infinity.Udp/Reliable/UdpPacket.cs b/Infinity.Udp/Reliable/UdpPacket.cs
@@ -95,8 +95,8 @@ public async Task<int> Resend()
 
                     try
                     {
-                        await connection.WriteBytesToConnection(writer).ConfigureAwait(false);
                         connection.Statistics.LogMessageResent(writer.Length);
+                        await connection.WriteBytesToConnection(writer, false).ConfigureAwait(false);
 
                         return 1;
                     }
diff --git a/Infinity.Udp/UdpClientConnection.cs b/Infinity.Udp/UdpClientConnection.cs
@@ -13,8 +13,6 @@ public sealed class UdpClientConnection : UdpConnection
 
         private ManualResetEvent connect_wait_lock = new ManualResetEvent(false);
 
-        private CancellationTokenSource cancellation_token_source = new CancellationTokenSource();
-
         private readonly Channel<MessageReader> _incoming = Channel.CreateUnbounded<MessageReader>();
 
         public UdpClientConnection(ILogger _logger, IPEndPoint _remote_end_point, IPMode _ip_mode = IPMode.IPv4)
@@ -71,7 +69,7 @@ private Socket CreateSocket(IPMode _ip_mode)
             Dispose(true);
         }
 
-        public override async Task WriteBytesToConnection(MessageWriter _writer)
+        public override async Task WriteBytesToConnection(MessageWriter _writer, bool _recycle_writer = true)
         {
 #if DEBUG
             if (TestLagMs > 0)
@@ -84,6 +82,11 @@ public override async Task WriteBytesToConnection(MessageWriter _writer)
             {
                 await WriteBytesToConnectionReal(_writer.Buffer, _writer.Length).ConfigureAwait(false);
             }
+
+            if (_recycle_writer)
+            {
+                _writer.Recycle();
+            }
         }
 
         public override void WriteBytesToConnectionSync(MessageWriter _writer)
@@ -282,8 +285,6 @@ protected override void DisconnectRemote(string _reason, MessageReader _reader)
                 InvokeDisconnected(_reason, _reader);
             }
 
-            writer.Recycle();
-
             Dispose();
         }
 
@@ -340,7 +341,6 @@ protected override void Dispose(bool _disposing)
                         // send disconnect packet to server
                         var writer = UdpMessageFactory.BuildDisconnectMessage();
                         SendDisconnect(writer);
-                        writer.Recycle();
 
                         // Fire client-side Disconnected event
                         InvokeDisconnected("Disposed", null);
diff --git a/Infinity.Udp/UdpConnection.cs b/Infinity.Udp/UdpConnection.cs
@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using Infinity.Core;
 using Infinity.Core.Exceptions;
 
@@ -20,13 +20,18 @@ public UdpConnectionConfiguration Configuration
 
         internal UdpConnectionConfiguration configuration;
 
+        private readonly Channel<MessageWriter> _outgoing = Channel.CreateUnbounded<MessageWriter>();
+        internal CancellationTokenSource cancellation_token_source = new CancellationTokenSource();
+
         public UdpConnection(ILogger _logger) : base()
         {
             configuration = new UdpConnectionConfiguration();
             logger = _logger;
+
+            Util.FireAndForget(SendInternal(), logger);
         }
 
-        public abstract Task WriteBytesToConnection(MessageWriter _writer);
+        public abstract Task WriteBytesToConnection(MessageWriter _writer, bool _recycle_writer = true);
         public abstract void WriteBytesToConnectionSync(MessageWriter _writer);
 
         protected abstract Task ShareConfiguration();
@@ -46,11 +51,17 @@ public SendErrors SendSync(MessageWriter _writer)
 
         public override async Task<SendErrors> Send(MessageWriter _writer)
         {
-            try
+            await _outgoing.Writer.WriteAsync(_writer, cancellation_token_source.Token);
+            return SendErrors.None;
+        }
+
+        public async Task SendInternal()
+        {
+            await foreach (var _writer in _outgoing.Reader.ReadAllAsync(cancellation_token_source.Token).ConfigureAwait(false))
             {
                 if (state != ConnectionState.Connected)
                 {
-                    return SendErrors.Disconnected;
+                    return;
                 }
 
                 InvokeBeforeSend(_writer);
@@ -65,7 +76,6 @@ public override async Task<SendErrors> Send(MessageWriter _writer)
                             }
 
                             await ReliableSend(_writer).ConfigureAwait(false);
-                            _writer.Recycle();
 
                             break;
                         }
@@ -78,7 +88,6 @@ public override async Task<SendErrors> Send(MessageWriter _writer)
 
                             await OrderedSend(_writer).ConfigureAwait(false);
                             Statistics.LogReliableMessageSent(_writer.Length);
-                            _writer.Recycle();
 
                             break;
                         }
@@ -92,7 +101,6 @@ public override async Task<SendErrors> Send(MessageWriter _writer)
                                 }
 
                                 await FragmentedSend(_writer).ConfigureAwait(false);
-                                _writer.Recycle();
 
                                 Statistics.LogFragmentedMessageSent(_writer.Length);
                             }
@@ -105,21 +113,13 @@ public override async Task<SendErrors> Send(MessageWriter _writer)
                         }
                     default: // applies to disconnect and unreliable
                         {
-                            await WriteBytesToConnection(_writer).ConfigureAwait(false);
-                            _writer.Recycle();
-
                             Statistics.LogUnreliableMessageSent(_writer.Length);
+                            await WriteBytesToConnection(_writer).ConfigureAwait(false);
 
                             break;
                         }
                 }
             }
-            finally
-            {
-                _writer.Recycle();
-            }
-
-            return SendErrors.None;
         }
 
         protected internal virtual async Task HandleReceive(MessageReader _reader, int _bytes_received)
diff --git a/Infinity.Udp/UdpConnectionListener.cs b/Infinity.Udp/UdpConnectionListener.cs
diff --git a/Infinity.Udp/UdpServerConnection.cs b/Infinity.Udp/UdpServerConnection.cs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace Infinity.Core`
`4`	`4`	`{`
`5`		`- public delegate bool HandshakeCheck(IPEndPoint _endPoint, MessageReader _reader, out byte[] _response);`
	`5`	`+ public delegate bool HandshakeCheck(IPEndPoint _endPoint, MessageReader _reader, out MessageWriter _response);`
`6`	`6`
`7`	`7`	`public abstract class NetworkConnectionListener : IDisposable`
`8`	`8`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public async Task Test_Receive(MessageWriter msg)`
`37`	`37`	`await HandleReceive(data, data.Length);`
`38`	`38`	`}`
`39`	`39`
`40`		`- public override async Task WriteBytesToConnection(MessageWriter _writer)`
	`40`	`+ public override async Task WriteBytesToConnection(MessageWriter _writer, bool _recycle_writer)`
`41`	`41`	`{`
`42`	`42`	`BytesSent.Add(MessageReader.Get(_writer.Buffer, 0, _writer.Length));`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,7 @@ public async Task UdpHandshakeTest()`
`175`	`175`	`// Use TaskCompletionSource for async signaling`
`176`	`176`	`var tcs = new TaskCompletionSource();`
`177`	`177`
`178`		`- listener.HandshakeConnection = (IPEndPoint endPoint, MessageReader input, out byte[] response) =>`
	`178`	`+ listener.HandshakeConnection = (IPEndPoint endPoint, MessageReader input, out MessageWriter response) =>`
`179`	`179`	`{`
`180`	`180`	`response = null;`
`181`	`181`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,8 @@ private async Task FragmentedSend(MessageWriter _writer)`
`40`	`40`	`await Task.Delay(10);`
`41`	`41`	`}`
`42`	`42`
	`43`	`+ _writer.Recycle();`
	`44`	`+`
`43`	`45`	`if (last_fragment_id_allocated >= byte.MaxValue)`
`44`	`46`	`{`
`45`	`47`	`Interlocked.Exchange(ref last_fragment_id_allocated, 0);`
Original file line number	Diff line number	Diff line change
`@@ -35,9 +35,8 @@ internal async Task<int> ManageReliablePackets()`
`35`	`35`	`protected async Task ReliableSend(MessageWriter _writer, Action _ack_callback = null)`
`36`	`36`	`{`
`37`	`37`	`AttachReliableID(_writer, 1, _ack_callback);`
`38`		`- await WriteBytesToConnection(_writer).ConfigureAwait(false);`
`39`	`38`	`Statistics.LogReliableMessageSent(_writer.Length);`
`40`		`- _writer.Recycle();`
	`39`	`+ await WriteBytesToConnection(_writer).ConfigureAwait(false);`
`41`	`40`	`}`
`42`	`41`
`43`	`42`	`private async Task ReliableMessageReceive(MessageReader _reader)`
Original file line number	Diff line number	Diff line change
`@@ -95,8 +95,8 @@ public async Task<int> Resend()`
`95`	`95`
`96`	`96`	`try`
`97`	`97`	`{`
`98`		`- await connection.WriteBytesToConnection(writer).ConfigureAwait(false);`
`99`	`98`	`connection.Statistics.LogMessageResent(writer.Length);`
	`99`	`+ await connection.WriteBytesToConnection(writer, false).ConfigureAwait(false);`
`100`	`100`
`101`	`101`	`return 1;`
`102`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,6 @@ public sealed class UdpClientConnection : UdpConnection`
`13`	`13`
`14`	`14`	`private ManualResetEvent connect_wait_lock = new ManualResetEvent(false);`
`15`	`15`
`16`		`- private CancellationTokenSource cancellation_token_source = new CancellationTokenSource();`
`17`		`-`
`18`	`16`	`private readonly Channel<MessageReader> _incoming = Channel.CreateUnbounded<MessageReader>();`
`19`	`17`
`20`	`18`	`public UdpClientConnection(ILogger _logger, IPEndPoint _remote_end_point, IPMode _ip_mode = IPMode.IPv4)`
`@@ -71,7 +69,7 @@ private Socket CreateSocket(IPMode _ip_mode)`
`71`	`69`	`Dispose(true);`
`72`	`70`	`}`
`73`	`71`
`74`		`- public override async Task WriteBytesToConnection(MessageWriter _writer)`
	`72`	`+ public override async Task WriteBytesToConnection(MessageWriter _writer, bool _recycle_writer = true)`
`75`	`73`	`{`
`76`	`74`	`#if DEBUG`
`77`	`75`	`if (TestLagMs > 0)`
`@@ -84,6 +82,11 @@ public override async Task WriteBytesToConnection(MessageWriter _writer)`
`84`	`82`	`{`
`85`	`83`	`await WriteBytesToConnectionReal(_writer.Buffer, _writer.Length).ConfigureAwait(false);`
`86`	`84`	`}`
	`85`	`+`
	`86`	`+ if (_recycle_writer)`
	`87`	`+ {`
	`88`	`+ _writer.Recycle();`
	`89`	`+ }`
`87`	`90`	`}`
`88`	`91`
`89`	`92`	`public override void WriteBytesToConnectionSync(MessageWriter _writer)`
`@@ -282,8 +285,6 @@ protected override void DisconnectRemote(string _reason, MessageReader _reader)`
`282`	`285`	`InvokeDisconnected(_reason, _reader);`
`283`	`286`	`}`
`284`	`287`
`285`		`- writer.Recycle();`
`286`		`-`
`287`	`288`	`Dispose();`
`288`	`289`	`}`
`289`	`290`
`@@ -340,7 +341,6 @@ protected override void Dispose(bool _disposing)`
`340`	`341`	`// send disconnect packet to server`
`341`	`342`	`var writer = UdpMessageFactory.BuildDisconnectMessage();`
`342`	`343`	`SendDisconnect(writer);`
`343`		`- writer.Recycle();`
`344`	`344`
`345`	`345`	`// Fire client-side Disconnected event`
`346`	`346`	`InvokeDisconnected("Disposed", null);`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using System.Threading.Tasks;`
	`1`	`+using System.Threading.Channels;`
`2`	`2`	`using Infinity.Core;`
`3`	`3`	`using Infinity.Core.Exceptions;`
`4`	`4`
`@@ -20,13 +20,18 @@ public UdpConnectionConfiguration Configuration`
`20`	`20`
`21`	`21`	`internal UdpConnectionConfiguration configuration;`
`22`	`22`
	`23`	`+ private readonly Channel<MessageWriter> _outgoing = Channel.CreateUnbounded<MessageWriter>();`
	`24`	`+ internal CancellationTokenSource cancellation_token_source = new CancellationTokenSource();`
	`25`	`+`
`23`	`26`	`public UdpConnection(ILogger _logger) : base()`
`24`	`27`	`{`
`25`	`28`	`configuration = new UdpConnectionConfiguration();`
`26`	`29`	`logger = _logger;`
	`30`	`+`
	`31`	`+ Util.FireAndForget(SendInternal(), logger);`
`27`	`32`	`}`
`28`	`33`
`29`		`- public abstract Task WriteBytesToConnection(MessageWriter _writer);`
	`34`	`+ public abstract Task WriteBytesToConnection(MessageWriter _writer, bool _recycle_writer = true);`
`30`	`35`	`public abstract void WriteBytesToConnectionSync(MessageWriter _writer);`
`31`	`36`
`32`	`37`	`protected abstract Task ShareConfiguration();`
`@@ -46,11 +51,17 @@ public SendErrors SendSync(MessageWriter _writer)`
`46`	`51`
`47`	`52`	`public override async Task<SendErrors> Send(MessageWriter _writer)`
`48`	`53`	`{`
`49`		`- try`
	`54`	`+ await _outgoing.Writer.WriteAsync(_writer, cancellation_token_source.Token);`
	`55`	`+ return SendErrors.None;`
	`56`	`+ }`
	`57`	`+`
	`58`	`+ public async Task SendInternal()`
	`59`	`+ {`
	`60`	`+ await foreach (var _writer in _outgoing.Reader.ReadAllAsync(cancellation_token_source.Token).ConfigureAwait(false))`
`50`	`61`	`{`
`51`	`62`	`if (state != ConnectionState.Connected)`
`52`	`63`	`{`
`53`		`- return SendErrors.Disconnected;`
	`64`	`+ return;`
`54`	`65`	`}`
`55`	`66`
`56`	`67`	`InvokeBeforeSend(_writer);`
`@@ -65,7 +76,6 @@ public override async Task<SendErrors> Send(MessageWriter _writer)`
`65`	`76`	`}`
`66`	`77`
`67`	`78`	`await ReliableSend(_writer).ConfigureAwait(false);`
`68`		`- _writer.Recycle();`
`69`	`79`
`70`	`80`	`break;`
`71`	`81`	`}`
`@@ -78,7 +88,6 @@ public override async Task<SendErrors> Send(MessageWriter _writer)`
`78`	`88`
`79`	`89`	`await OrderedSend(_writer).ConfigureAwait(false);`
`80`	`90`	`Statistics.LogReliableMessageSent(_writer.Length);`
`81`		`- _writer.Recycle();`
`82`	`91`
`83`	`92`	`break;`
`84`	`93`	`}`
`@@ -92,7 +101,6 @@ public override async Task<SendErrors> Send(MessageWriter _writer)`
`92`	`101`	`}`
`93`	`102`
`94`	`103`	`await FragmentedSend(_writer).ConfigureAwait(false);`
`95`		`- _writer.Recycle();`
`96`	`104`
`97`	`105`	`Statistics.LogFragmentedMessageSent(_writer.Length);`
`98`	`106`	`}`
`@@ -105,21 +113,13 @@ public override async Task<SendErrors> Send(MessageWriter _writer)`
`105`	`113`	`}`
`106`	`114`	`default: // applies to disconnect and unreliable`
`107`	`115`	`{`
`108`		`- await WriteBytesToConnection(_writer).ConfigureAwait(false);`
`109`		`- _writer.Recycle();`
`110`		`-`
`111`	`116`	`Statistics.LogUnreliableMessageSent(_writer.Length);`
	`117`	`+ await WriteBytesToConnection(_writer).ConfigureAwait(false);`
`112`	`118`
`113`	`119`	`break;`
`114`	`120`	`}`
`115`	`121`	`}`
`116`	`122`	`}`
`117`		`- finally`
`118`		`- {`
`119`		`- _writer.Recycle();`
`120`		`- }`
`121`		`-`
`122`		`- return SendErrors.None;`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`protected internal virtual async Task HandleReceive(MessageReader _reader, int _bytes_received)`