Disable Nagle algorithm for reduced latency

SerializersBenchmark/Network/Abstractions/TcpServer.cs

@@ -5,7 +5,7 @@ namespace SerializersBenchmark.Network.Abstractions;
 
 public abstract class TcpServer(int port) : IServer
 {
-    private readonly TcpListener _tcpListener = new(IPAddress.Parse("127.0.0.1"), port);
+    private readonly TcpListener _tcpListener = new(IPAddress.Loopback, port);
     private TcpClient _connectedClient;
     protected bool TeardownStarted;
 
@@ -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

@@ -1,44 +1,54 @@
-using System.Net.Sockets;
+using System.Net;
+using System.Net.Sockets;
 using SerializersBenchmark.Base;
 using SerializersBenchmark.Network.Abstractions;
 
 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(IPAddress.Loopback, _port).ConfigureAwait(false);
         _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);
+        await stream.FlushAsync().ConfigureAwait(false);
     }
 
     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()