better stuff

GuilhermeStrice · GuilhermeStrice · commit 5c3de40d1984 · 2025-11-07T04:35:17.000Z
diff --git a/Infinity.Multiplexer/Infinity.Multiplexer.csproj b/Infinity.Multiplexer/Infinity.Multiplexer.csproj
@@ -3,7 +3,7 @@
   <ItemGroup>
     <ProjectReference Include="..\Infinity.Core\Infinity.Core.csproj" />
     <ProjectReference Include="..\Infinity.Udp\Infinity.Udp.csproj" />
-    <ProjectReference Include="..\Infinity.WebSockets\Infinity.WebSockets.csproj" />
+    <ProjectReference Include="..\Infinity.Websockets\Infinity.Websockets.csproj" />
   </ItemGroup>
 
   <PropertyGroup>
diff --git a/Infinity.Tests/Infinity.Udp.Tests/Global.cs b/Infinity.Tests/Infinity.Udp.Tests/Global.cs
@@ -0,0 +1,2 @@
+global using Xunit;
+[assembly: CollectionBehavior(DisableTestParallelization = true)]
diff --git a/Infinity.Tests/Infinity.Udp.Tests/NoConnectionUdpConnection.cs b/Infinity.Tests/Infinity.Udp.Tests/NoConnectionUdpConnection.cs
@@ -37,9 +37,9 @@ public async Task Test_Receive(MessageWriter msg)
             await HandleReceive(data, data.Length);
         }
 
-        public override async Task WriteBytesToConnection(byte[] _bytes, int _length)
+        public override async Task WriteBytesToConnection(MessageWriter _writer)
         {
-            BytesSent.Add(MessageReader.Get(_bytes));
+            BytesSent.Add(MessageReader.Get(_writer.Buffer));
         }
 
         public override async Task Connect(MessageWriter _writer, int _timeout = 5000)
@@ -60,7 +60,7 @@ protected override void DisconnectInternal(InfinityInternalErrors _error, string
         {
         }
 
-        public override void WriteBytesToConnectionSync(byte[] _bytes, int _length)
+        public override void WriteBytesToConnectionSync(MessageWriter _writer)
         {
             throw new NotImplementedException();
         }
diff --git a/Infinity.Tests/Infinity.Udp.Tests/UdpReliabilityTests.cs b/Infinity.Tests/Infinity.Udp.Tests/UdpReliabilityTests.cs
@@ -39,8 +39,6 @@ public async Task TestReliableWrapOffByOne()
             SetReliableId(data, 9);
             await conn.Test_Receive(data);
 
-            data.Recycle();
-
             // Both messages should be received.
             Assert.Equal(2, messagesReceived.Count);
             messagesReceived.Clear();
@@ -101,8 +99,6 @@ public async Task TestThatAllMessagesAreReceived()
             }
 
             conn.Dispose();
-
-            data.Recycle();
         }
 
         [Fact]
@@ -143,8 +139,6 @@ public async Task TestAcksForNotReceivedMessages()
             }
 
             conn.Dispose();
-
-            data.Recycle();
         }
 
         private static void SetReliableId(MessageWriter data, int i)
diff --git a/Infinity.Tests/Infinity.Udp.Tests/UdpTestHelper.cs b/Infinity.Tests/Infinity.Udp.Tests/UdpTestHelper.cs
@@ -187,7 +187,6 @@ public static async Task RunClientDisconnectTest(UdpConnectionListener listener,
 
             var writer = UdpMessageFactory.BuildDisconnectMessage();
             connection.Disconnect("Testing", writer);
-            writer.Recycle();
 
             mutex2.WaitOne(2500);
 
diff --git a/Infinity.Udp/Fragmented/UdpConnection.Fragmented.cs b/Infinity.Udp/Fragmented/UdpConnection.Fragmented.cs
@@ -12,37 +12,29 @@ public partial class UdpConnection
 
         private const byte fragment_header_size = sizeof(byte) + sizeof(ushort) + sizeof(int) + sizeof(byte) + sizeof(ushort);
 
-        private async Task FragmentedSend(byte[] _buffer)
+        private async Task FragmentedSend(MessageWriter _writer)
         {
             var fragment_size = MTU - fragment_header_size;
 
             var fragment_id = (byte)Interlocked.Increment(ref last_fragment_id_allocated);
             
-            var fragments_count = (int)((_buffer.Length / (double)fragment_size) + 1);
+            var fragments_count = (int)((_writer.Buffer.Length / (double)fragment_size) + 1);
 
             for (ushort i = 0; i < fragments_count; i++)
             {
-                var data_length = Math.Min(fragment_size, _buffer.Length - fragment_size * i);
-                var fragment_buffer = new byte[data_length + fragment_header_size];
+                var data_length = Math.Min(fragment_size, _writer.Buffer.Length - fragment_size * i);
+                var fragment_writer = MessageWriter.Get();
+                //var fragment_buffer = new byte[data_length + fragment_header_size];
 
-                fragment_buffer[0] = UdpSendOptionInternal.Fragment;
+                fragment_writer.Write(UdpSendOptionInternal.Fragment);
 
-                AttachReliableID(fragment_buffer, 1);
+                AttachReliableID(fragment_writer, 1);
 
-                fragment_buffer[3] = (byte)fragments_count;
-                fragment_buffer[4] = (byte)(fragments_count >> 8);
-                fragment_buffer[5] = (byte)(fragments_count >> 16);
-                fragment_buffer[6] = (byte)(fragments_count >> 24);
+                fragment_writer.Write(fragments_count);
+                fragment_writer.Write(fragment_id);
+                fragment_writer.Write(i);
 
-                fragment_buffer[7] = fragment_id;
-
-                // Add fragment sequence index
-                fragment_buffer[8] = (byte)i;
-                fragment_buffer[9] = (byte)(i >> 8);
-
-                Array.Copy(_buffer, fragment_size * i, fragment_buffer, fragment_header_size, data_length);
-                
-                await WriteBytesToConnection(fragment_buffer, fragment_buffer.Length);
+                await WriteBytesToConnection(fragment_writer).ConfigureAwait(false);
             }
 
             if (last_fragment_id_allocated >= byte.MaxValue)
diff --git a/Infinity.Udp/Fragmented/UdpConnection.MTU.cs b/Infinity.Udp/Fragmented/UdpConnection.MTU.cs
@@ -88,7 +88,15 @@ private async Task ExpandMTU()
 
                 buffer[0] = UdpSendOptionInternal.TestMTU;
 
-                AttachReliableID(buffer, 1, async () =>
+                buffer[mtu - 4] = (byte)mtu;
+                buffer[mtu - 3] = (byte)(mtu >> 8);
+                buffer[mtu - 2] = (byte)(mtu >> 16);
+                buffer[mtu - 1] = (byte)(mtu >> 24);
+
+                var writer = MessageWriter.Get();
+                writer.Write(buffer, 0, buffer.Length);
+
+                AttachReliableID(writer, 1, async () =>
                 {
                     await mtu_lock.WaitAsync().ConfigureAwait(false);
                     try
@@ -110,12 +118,7 @@ private async Task ExpandMTU()
                     await ExpandMTU().ConfigureAwait(false);
                 });
 
-                buffer[MTU - 4] = (byte)MTU;
-                buffer[MTU - 3] = (byte)(MTU >> 8);
-                buffer[MTU - 2] = (byte)(MTU >> 16);
-                buffer[MTU - 1] = (byte)(MTU >> 24);
-
-                await WriteBytesToConnection(buffer, MTU);
+                await WriteBytesToConnection(writer).ConfigureAwait(false);
             }
             finally
             {
diff --git a/Infinity.Udp/KeepAlive/UdpConnection.KeepAlive.cs b/Infinity.Udp/KeepAlive/UdpConnection.KeepAlive.cs
@@ -81,13 +81,13 @@ private async Task SendPing()
         {
             ushort id = (ushort)Interlocked.Increment(ref last_id_allocated);
 
-            byte[] bytes = new byte[3];
-            bytes[0] = UdpSendOptionInternal.Ping;
-            bytes[1] = (byte)(id >> 8);
-            bytes[2] = (byte)id;
+            var writer = MessageWriter.Get();
+
+            writer.Write(UdpSendOptionInternal.Ping);
+            writer.Write(id);
 
             active_pings.AddPing(id);
-            WriteBytesToConnection(bytes, bytes.Length);
+            await WriteBytesToConnection(writer).ConfigureAwait(false);
             Statistics.LogPingSent(3);
         }
     }
diff --git a/Infinity.Udp/Ordered/UdpConnection.Ordered.cs b/Infinity.Udp/Ordered/UdpConnection.Ordered.cs
@@ -11,13 +11,13 @@ public partial class UdpConnection
         private volatile int send_sequence = 0;
         private volatile int receive_sequence = 0;
 
-        private async Task OrderedSend(byte[] _buffer)
+        private async Task OrderedSend(MessageWriter _writer)
         {
-            AttachReliableID(_buffer, 1);
+            AttachReliableID(_writer, 1);
 
-            _buffer[3] = (byte)send_sequence;
+            _writer.Buffer[3] = (byte)send_sequence;
 
-            await WriteBytesToConnection(_buffer, _buffer.Length);
+            await WriteBytesToConnection(_writer).ConfigureAwait(false);
 
             send_sequence = (byte)Interlocked.Increment(ref send_sequence);
         }
diff --git a/Infinity.Udp/Reliable/UdpConnection.Ack.cs b/Infinity.Udp/Reliable/UdpConnection.Ack.cs
@@ -61,15 +61,12 @@ private async Task SendAck(ushort _id)
                 }
             }
 
-            byte[] bytes = new byte[]
-            {
-                UdpSendOptionInternal.Acknowledgement,
-                (byte)(_id >> 8),
-                (byte)(_id >> 0),
-                recent_packets
-            };
+            var writer = MessageWriter.Get();
+            writer.Write(UdpSendOptionInternal.Acknowledgement);
+            writer.Write(_id);
+            writer.Write(recent_packets);
 
-            await WriteBytesToConnection(bytes, bytes.Length);
+            await WriteBytesToConnection(writer).ConfigureAwait(false);
         }
     }
 }
diff --git a/Infinity.Udp/Reliable/UdpConnection.Reliable.cs b/Infinity.Udp/Reliable/UdpConnection.Reliable.cs
@@ -32,11 +32,12 @@ internal async Task<int> ManageReliablePackets()
             return output;
         }
 
-        protected async Task ReliableSend(byte[] _buffer, Action _ack_callback = null)
+        protected async Task ReliableSend(MessageWriter _writer, Action _ack_callback = null)
         {
-            AttachReliableID(_buffer, 1, _ack_callback);
-            await WriteBytesToConnection(_buffer, _buffer.Length);
-            Statistics.LogReliableMessageSent(_buffer.Length);
+            AttachReliableID(_writer, 1, _ack_callback);
+            await WriteBytesToConnection(_writer).ConfigureAwait(false);
+            Statistics.LogReliableMessageSent(_writer.Buffer.Length);
+            _writer.Recycle();
         }
 
         private async Task ReliableMessageReceive(MessageReader _reader)
@@ -65,12 +66,11 @@ private void DisposeReliablePackets()
             }
         }
 
-        protected void AttachReliableID(byte[] _buffer, int _offset, Action _ack_callback = null)
+        protected void AttachReliableID(MessageWriter _writer, int _offset, Action _ack_callback = null)
         {
             ushort id = (ushort)Interlocked.Increment(ref last_id_allocated);
 
-            _buffer[_offset] = (byte)(id >> 8);
-            _buffer[_offset + 1] = (byte)id;
+            _writer.Write(id);
 
             int resend_delay_ms = configuration.ResendTimeoutMs;
             if (resend_delay_ms <= 0)
@@ -82,7 +82,7 @@ protected void AttachReliableID(byte[] _buffer, int _offset, Action _ack_callbac
             UdpPacket packet = Pools.PacketPool.GetObject();
             packet.Set(
                 this,
-                _buffer,
+                _writer,
                 resend_delay_ms,
                 _ack_callback);
 
diff --git a/Infinity.Udp/Reliable/UdpPacket.cs b/Infinity.Udp/Reliable/UdpPacket.cs
@@ -29,14 +29,14 @@ private set
 
         public Stopwatch Stopwatch = new Stopwatch();
 
-        private byte[]? buffer;
         private int retransmissions;
+        private MessageWriter writer;
         private UdpConnection? connection;
 
-        public void Set(UdpConnection _connection, byte[] _buffer, int _timeout, Action _ack_callback)
+        public void Set(UdpConnection _connection, MessageWriter _writer, int _timeout, Action _ack_callback)
         {
             connection = _connection;
-            buffer = _buffer;
+            writer = _writer;
 
             Acknowledged = false;
             NextTimeoutMs = _timeout;
@@ -50,14 +50,14 @@ public async Task<int> Resend()
         {
             if (!Acknowledged && connection != null)
             {
-                ushort id = (ushort)((buffer[1] << 8) + buffer[2]);
+                ushort id = (ushort)((writer.Buffer[1] << 8) + writer.Buffer[2]);
 
                 long lifetimeMs = Stopwatch.ElapsedMilliseconds;
                 if (lifetimeMs >= connection.configuration.DisconnectTimeoutMs)
                 {
                     if (connection.reliable_data_packets_sent.TryRemove(id, out UdpPacket self))
                     {
-                        connection.DisconnectInternalPacket(InfinityInternalErrors.ReliablePacketWithoutResponse, $"Reliable packet {id} (size={buffer.Length}) was not ack'd after {lifetimeMs}ms ({self.Retransmissions} resends)");
+                        connection.DisconnectInternalPacket(InfinityInternalErrors.ReliablePacketWithoutResponse, $"Reliable packet {id} (size={writer.Length}) was not ack'd after {lifetimeMs}ms ({self.Retransmissions} resends)");
                         self.Recycle();
                     }
 
@@ -78,7 +78,7 @@ public async Task<int> Resend()
                     {
                         if (connection.reliable_data_packets_sent.TryRemove(id, out UdpPacket self))
                         {
-                            connection.DisconnectInternalPacket(InfinityInternalErrors.ReliablePacketWithoutResponse, $"Reliable packet {id} (size={buffer.Length}) was not ack'd after {self.Retransmissions} resends ({lifetimeMs}ms)");
+                            connection.DisconnectInternalPacket(InfinityInternalErrors.ReliablePacketWithoutResponse, $"Reliable packet {id} (size={writer.Length}) was not ack'd after {self.Retransmissions} resends ({lifetimeMs}ms)");
                             self.Recycle();
                         }
 
@@ -95,8 +95,8 @@ public async Task<int> Resend()
 
                     try
                     {
-                        connection.WriteBytesToConnection(buffer, buffer.Length);
-                        connection.Statistics.LogMessageResent(buffer.Length);
+                        await connection.WriteBytesToConnection(writer).ConfigureAwait(false);
+                        connection.Statistics.LogMessageResent(writer.Length);
 
                         return 1;
                     }
@@ -113,6 +113,7 @@ public async Task<int> Resend()
         public void Recycle()
         {
             Acknowledged = true;
+            writer.Recycle();
 
             Pools.PacketPool.PutObject(this);
         }
diff --git a/Infinity.Udp/UdpClientConnection.cs b/Infinity.Udp/UdpClientConnection.cs
@@ -69,26 +69,27 @@ private Socket CreateSocket(IPMode _ip_mode)
             Dispose(true);
         }
 
-        public override async Task WriteBytesToConnection(byte[] _bytes, int _length)
+        public override async Task WriteBytesToConnection(MessageWriter _writer)
         {
 #if DEBUG
             if (TestLagMs > 0)
             {
                 Thread.Sleep(TestLagMs);
-                await WriteBytesToConnectionReal(_bytes, _length);
+                await WriteBytesToConnectionReal(_writer.Buffer, _writer.Length).ConfigureAwait(false);
             }
             else
 #endif
             {
-                await WriteBytesToConnectionReal(_bytes, _length);
+                await WriteBytesToConnectionReal(_writer.Buffer, _writer.Length).ConfigureAwait(false);
+                await WriteBytesToConnectionReal(_writer.Buffer, _writer.Length).ConfigureAwait(false);
             }
         }
 
-        public override void WriteBytesToConnectionSync(byte[] _bytes, int _length)
+        public override void WriteBytesToConnectionSync(MessageWriter _writer)
         {
             try
             {
-                int sent = socket.SendTo(_bytes, _length, SocketFlags.None, EndPoint);
+                int sent = socket.SendTo(_writer.Buffer, _writer.Length, SocketFlags.None, EndPoint);
                 Statistics.LogPacketSent(sent);
             }
             catch (SocketException ex) when (ex.SocketErrorCode == SocketError.MessageSize)
@@ -99,6 +100,10 @@ public override void WriteBytesToConnectionSync(byte[] _bytes, int _length)
             {
                 // this is handles by keep alive and packet resends
             }
+            finally
+            {
+                _writer.Recycle();
+            }
         }
 
         public override async Task Connect(MessageWriter _writer, int _timeout = 5000)
@@ -163,18 +168,14 @@ private async Task WriteBytesToConnectionReal(byte[] _bytes, int _length)
 
         private async Task SendHandshake(MessageWriter _writer, Action _acknowledge_callback)
         {
-            byte[] buffer = new byte[_writer.Length];
-            Array.Copy(_writer.Buffer, 0, buffer, 0, _writer.Length);
-
-            await ReliableSend(buffer, _acknowledge_callback);
+            await ReliableSend(_writer, _acknowledge_callback).ConfigureAwait(false);
         }
 
         private async Task AskConfiguration()
         {
-            byte[] buffer = new byte[3];
-            buffer[0] = UdpSendOptionInternal.AskConfiguration;
+            var writer = UdpMessageFactory.BuildAskConfirurationMessage();
 
-            await ReliableSend(buffer);
+            await ReliableSend(writer).ConfigureAwait(false);
         }
 
         private async Task ManageReliablePacketsInternal()
diff --git a/Infinity.Udp/UdpConnection.cs b/Infinity.Udp/UdpConnection.cs
diff --git a/Infinity.Udp/UdpServerConnection.cs b/Infinity.Udp/UdpServerConnection.cs
diff --git a/Infinity.WebSockets/WebSocketClientConnection.cs b/Infinity.WebSockets/WebSocketClientConnection.cs
diff --git a/Infinity.WebSockets/WebSocketFrame.cs b/Infinity.WebSockets/WebSocketFrame.cs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+global using Xunit;`
	`2`	`+[assembly: CollectionBehavior(DisableTestParallelization = true)]`
Original file line number	Diff line number	Diff line change
`@@ -37,9 +37,9 @@ public async Task Test_Receive(MessageWriter msg)`
`37`	`37`	`await HandleReceive(data, data.Length);`
`38`	`38`	`}`
`39`	`39`
`40`		`- public override async Task WriteBytesToConnection(byte[] _bytes, int _length)`
	`40`	`+ public override async Task WriteBytesToConnection(MessageWriter _writer)`
`41`	`41`	`{`
`42`		`- BytesSent.Add(MessageReader.Get(_bytes));`
	`42`	`+ BytesSent.Add(MessageReader.Get(_writer.Buffer));`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`public override async Task Connect(MessageWriter _writer, int _timeout = 5000)`
`@@ -60,7 +60,7 @@ protected override void DisconnectInternal(InfinityInternalErrors _error, string`
`60`	`60`	`{`
`61`	`61`	`}`
`62`	`62`
`63`		`- public override void WriteBytesToConnectionSync(byte[] _bytes, int _length)`
	`63`	`+ public override void WriteBytesToConnectionSync(MessageWriter _writer)`
`64`	`64`	`{`
`65`	`65`	`throw new NotImplementedException();`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,6 @@ public async Task TestReliableWrapOffByOne()`
`39`	`39`	`SetReliableId(data, 9);`
`40`	`40`	`await conn.Test_Receive(data);`
`41`	`41`
`42`		`- data.Recycle();`
`43`		`-`
`44`	`42`	`// Both messages should be received.`
`45`	`43`	`Assert.Equal(2, messagesReceived.Count);`
`46`	`44`	`messagesReceived.Clear();`
`@@ -101,8 +99,6 @@ public async Task TestThatAllMessagesAreReceived()`
`101`	`99`	`}`
`102`	`100`
`103`	`101`	`conn.Dispose();`
`104`		`-`
`105`		`- data.Recycle();`
`106`	`102`	`}`
`107`	`103`
`108`	`104`	`[Fact]`
`@@ -143,8 +139,6 @@ public async Task TestAcksForNotReceivedMessages()`
`143`	`139`	`}`
`144`	`140`
`145`	`141`	`conn.Dispose();`
`146`		`-`
`147`		`- data.Recycle();`
`148`	`142`	`}`
`149`	`143`
`150`	`144`	`private static void SetReliableId(MessageWriter data, int i)`
Original file line number	Diff line number	Diff line change
`@@ -81,13 +81,13 @@ private async Task SendPing()`
`81`	`81`	`{`
`82`	`82`	`ushort id = (ushort)Interlocked.Increment(ref last_id_allocated);`
`83`	`83`
`84`		`- byte[] bytes = new byte[3];`
`85`		`- bytes[0] = UdpSendOptionInternal.Ping;`
`86`		`- bytes[1] = (byte)(id >> 8);`
`87`		`- bytes[2] = (byte)id;`
	`84`	`+ var writer = MessageWriter.Get();`
	`85`	`+`
	`86`	`+ writer.Write(UdpSendOptionInternal.Ping);`
	`87`	`+ writer.Write(id);`
`88`	`88`
`89`	`89`	`active_pings.AddPing(id);`
`90`		`- WriteBytesToConnection(bytes, bytes.Length);`
	`90`	`+ await WriteBytesToConnection(writer).ConfigureAwait(false);`
`91`	`91`	`Statistics.LogPingSent(3);`
`92`	`92`	`}`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,13 +11,13 @@ public partial class UdpConnection`
`11`	`11`	`private volatile int send_sequence = 0;`
`12`	`12`	`private volatile int receive_sequence = 0;`
`13`	`13`
`14`		`- private async Task OrderedSend(byte[] _buffer)`
	`14`	`+ private async Task OrderedSend(MessageWriter _writer)`
`15`	`15`	`{`
`16`		`- AttachReliableID(_buffer, 1);`
	`16`	`+ AttachReliableID(_writer, 1);`
`17`	`17`
`18`		`- _buffer[3] = (byte)send_sequence;`
	`18`	`+ _writer.Buffer[3] = (byte)send_sequence;`
`19`	`19`
`20`		`- await WriteBytesToConnection(_buffer, _buffer.Length);`
	`20`	`+ await WriteBytesToConnection(_writer).ConfigureAwait(false);`
`21`	`21`
`22`	`22`	`send_sequence = (byte)Interlocked.Increment(ref send_sequence);`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,15 +61,12 @@ private async Task SendAck(ushort _id)`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`- byte[] bytes = new byte[]`
`65`		`- {`
`66`		`- UdpSendOptionInternal.Acknowledgement,`
`67`		`- (byte)(_id >> 8),`
`68`		`- (byte)(_id >> 0),`
`69`		`- recent_packets`
`70`		`- };`
	`64`	`+ var writer = MessageWriter.Get();`
	`65`	`+ writer.Write(UdpSendOptionInternal.Acknowledgement);`
	`66`	`+ writer.Write(_id);`
	`67`	`+ writer.Write(recent_packets);`
`71`	`68`
`72`		`- await WriteBytesToConnection(bytes, bytes.Length);`
	`69`	`+ await WriteBytesToConnection(writer).ConfigureAwait(false);`
`73`	`70`	`}`
`74`	`71`	`}`
`75`	`72`	`}`