Disable Nagle algorithm for reduced latency

Author: multiarc

SerializersBenchmark/Network/Abstractions/TcpServer.cs

@@ -21,6 +21,7 @@ public void Start()
                 while (true)
                 {
                     _connectedClient = await _tcpListener.AcceptTcpClientAsync();
+                    _connectedClient.Client.NoDelay = true;//disable Nagle's algorithm for low latency
                     await OnClientConnected(_connectedClient);
                 }
             }

SerializersBenchmark/Network/Rabbit.cs

@@ -4,28 +4,37 @@
 
 namespace SerializersBenchmark.Network;
 
-public sealed class Rabbit(ISerializerTestAsync serializer, int port, bool useBufferedStream = false) : IRabbit, ITcpClient
+public sealed class Rabbit : IRabbit, ITcpClient
 {
-    private readonly TcpClient _tcpClient = new();
+    private readonly TcpClient _tcpClient;
     private NetworkStream _networkStream;
+    private readonly ISerializerTestAsync _serializer;
+    private readonly int _port;
+    private readonly bool _useBufferedStream;
+    public Rabbit(ISerializerTestAsync serializer, int port, bool useBufferedStream = false) {
+        _serializer = serializer;
+        _port = port;
+        _useBufferedStream = useBufferedStream;
+        _tcpClient = new TcpClient();
+        _tcpClient.Client.NoDelay = true; //disable Nagle's algorithm for low latency
+    }
 
-    public async Task ConnectAsync()
-    {
-        await _tcpClient.ConnectAsync("127.0.0.1", port);
+    public async Task ConnectAsync() {
+        await _tcpClient.ConnectAsync("127.0.0.1", _port);
         _networkStream = _tcpClient.GetStream();
     }
 
     public async Task SendAsync(object value, int repeatCount)
     {
         Stream stream = _networkStream;
-        if (useBufferedStream)
+        if (_useBufferedStream)
         {
             stream = new BufferedStream(stream);
         }
 
         for (var i = 0; i < repeatCount; i++)
         {
-            await serializer.SerializeAsync(value, stream).ConfigureAwait(false);
+            await _serializer.SerializeAsync(value, stream).ConfigureAwait(false);
         }
 
         await _networkStream.FlushAsync().ConfigureAwait(false);
@@ -34,11 +43,11 @@ public async Task SendAsync(object value, int repeatCount)
     public async Task<object> ReceiveAsync(int expectedSize)
     {
         Stream stream = new LimitedStreamReader(_networkStream, expectedSize);
-        if (useBufferedStream)
+        if (_useBufferedStream)
         {
             stream = new BufferedStream(stream);
         }
-        return await serializer.DeserializeAsync(stream).ConfigureAwait(false);
+        return await _serializer.DeserializeAsync(stream).ConfigureAwait(false);
     }
 
     public void Dispose()