Warnings fixed

Christoph Bauer · Christoph Bauer · commit 598bb0167b6b · 2025-06-12T14:32:47.000+02:00
diff --git a/src/NetMQ.Tests/MessageTests.cs b/src/NetMQ.Tests/MessageTests.cs
@@ -128,7 +128,7 @@ public void Issue52_ReqToRouterBug()
 
                 var msg = router.ReceiveMultipartMessage();
                 Assert.Equal(3, msg.FrameCount);
-                Assert.Equal(msg[2].ConvertToString(), testmessage);
+                Assert.Equal(testmessage, msg[2].ConvertToString());
             }
         }
 
diff --git a/src/NetMQ.Tests/NetMQMonitorTests.cs b/src/NetMQ.Tests/NetMQMonitorTests.cs
@@ -57,9 +57,9 @@ public void Monitoring()
             }
         }
 
-#if !NET35
+
         [Fact]
-        public void StartAsync()
+        public async Task StartAsync()
         {
             using (var rep = new ResponseSocket())
             using (var monitor = new NetMQMonitor(rep, "inproc://foo", SocketEvents.Closed))
@@ -68,10 +68,11 @@ public void StartAsync()
                 Thread.Sleep(200);
                 Assert.Equal(TaskStatus.Running, task.Status);
                 monitor.Stop();
-                Assert.True(task.Wait(TimeSpan.FromMilliseconds(1000)));
+                var completedTask = await Task.WhenAny(task, Task.Delay(1000));
+                Assert.Equal(task, completedTask);
             }
         }
-#endif
+
 
         [Fact]
         public void NoHangWhenMonitoringUnboundInprocAddress()
@@ -126,7 +127,7 @@ public void ErrorCodeTest()
         }
 
         [Fact]
-        public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()
+        public async Task  MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()
         {
             // The bug:
             // Given we monitor a netmq tcp socket
@@ -141,7 +142,7 @@ public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()
                 using (var req = new RequestSocket())
                 {
                     monitor = new NetMQMonitor(req, "inproc://#monitor", SocketEvents.All);
-                    Task.Factory.StartNew(monitor.Start);
+                    _ = Task.Factory.StartNew(monitor.Start);
 
                     // Bug only occurs when monitoring a tcp socket
                     var port = res.BindRandomPort("tcp://127.0.0.1");
@@ -152,10 +153,12 @@ public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()
                     res.SendFrame("response");
                     Assert.Equal("response", req.ReceiveFrameString());
                 }
-                Thread.Sleep(100);
+
+                await Task.Delay(100);
                 // Monitor.Dispose should complete
-                var completed = Task.Factory.StartNew(() => monitor.Dispose()).Wait(1000);
-                Assert.True(completed);
+                var task = Task.Factory.StartNew(() => monitor.Dispose());
+                var completedTask = await Task.WhenAny(task, Task.Delay(1000));
+                Assert.Equal(task, completedTask);
             }
             // NOTE If this test fails, it will hang because context.Dispose will block
         }
diff --git a/src/NetMQ.Tests/NetMQPollerTest.cs b/src/NetMQ.Tests/NetMQPollerTest.cs
@@ -10,6 +10,7 @@
 
 #if !NET35
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 #endif
 
 // ReSharper disable AccessToDisposedClosure
@@ -865,7 +866,7 @@ public void NativeSocket()
 
 #if !NET35
         [Fact]
-        public void OneTask()
+        public async Task OneTask()
         {
             bool triggered = false;
 
@@ -879,27 +880,27 @@ public void OneTask()
                     Assert.True(poller.CanExecuteTaskInline, "Should be on NetMQPoller thread");
                 });
                 task.Start(poller);
-                task.Wait();
+                await task;
 
                 Assert.True(triggered);
             }
         }
 
         [Fact]
-        public void SetsCurrentTaskScheduler()
+        public async Task  SetsCurrentTaskScheduler()
         {
             using (var poller = new NetMQPoller())
             {
                 poller.RunAsync();
 
                 var task = new Task(() => Assert.Same(TaskScheduler.Current, poller));
                 task.Start(poller);
-                task.Wait();
+                await task;
             }
         }
 
         [Fact]
-        public void CanExecuteTaskInline()
+        public async Task CanExecuteTaskInline()
         {
             using (var poller = new NetMQPoller())
             {
@@ -911,12 +912,12 @@ public void CanExecuteTaskInline()
 
                 var task = new Task(() => Assert.True(poller.CanExecuteTaskInline));
                 task.Start(poller);
-                task.Wait();
+                await task;
             }
         }
 
         [Fact]
-        public void ContinueWith()
+        public async Task ContinueWith()
         {
             int threadId1 = 0;
             int threadId2 = 1;
@@ -941,8 +942,7 @@ public void ContinueWith()
                 }, poller);
 
                 task.Start(poller);
-                task.Wait();
-                task2.Wait();
+                await Task.WhenAll(new List<Task>{task, task2});
 
                 Assert.Equal(threadId1, threadId2);
                 Assert.Equal(1, runCount1);
@@ -951,7 +951,7 @@ public void ContinueWith()
         }
 
         [Fact]
-        public void TwoThreads()
+        public async Task TwoThreads()
         {
             int count1 = 0;
             int count2 = 0;
@@ -982,9 +982,8 @@ public void TwoThreads()
                     }
                 });
 
-                t1.Wait(1000);
-                t2.Wait(1000);
-                Task.WaitAll(allTasks.ToArray(), 1000);
+                 await Task.WhenAny(Task.WhenAll(new List<Task>{ t1, t2 }), Task.Delay(1000));
+                 await Task.WhenAny(Task.WhenAll(allTasks.ToArray()), Task.Delay(1000));
 
                 Assert.Equal(100, count1);
                 Assert.Equal(100, count2);
diff --git a/src/NetMQ.Tests/XPubSubTests.cs b/src/NetMQ.Tests/XPubSubTests.cs
@@ -332,7 +332,7 @@ public void Manual()
                 sub.SendFrame(new byte[] { 1, (byte)'A' });
                 var subscription = pub.ReceiveFrameBytes();
 
-                Assert.Equal(subscription[1], (byte)'A');
+                Assert.Equal((byte)'A', subscription[1]);
 
                 pub.Subscribe("B");
                 pub.SendFrame("A");
@@ -356,7 +356,7 @@ public void WelcomeMessage()
 
                 var subscription = pub.ReceiveFrameBytes();
 
-                Assert.Equal(subscription[1], (byte)'W');
+                Assert.Equal((byte)'W', subscription[1]);
 
                 Assert.Equal("W", sub.ReceiveFrameString());
             }
@@ -377,7 +377,7 @@ public void ClearWelcomeMessage()
 
                 var subscription = pub.ReceiveFrameBytes();
 
-                Assert.Equal(subscription[1], (byte)'W');
+                Assert.Equal( (byte)'W', subscription[1]);
 
                 Assert.False(sub.TrySkipFrame());
             }
diff --git a/src/NetMQ/Core/Transports/Tcp/TcpConnector.cs b/src/NetMQ/Core/Transports/Tcp/TcpConnector.cs
@@ -206,7 +206,7 @@ private void StartConnecting()
             // TerminatingException can occur in above call to EventConnectDelayed via
             // MonitorEvent.Write if corresponding PairSocket has been sent Term command
             catch (TerminatingException)
-            {}
+            { }
         }
 
         /// <summary>
@@ -236,9 +236,12 @@ public void OutCompleted(SocketError socketError, int bytesTransferred)
                 m_ioObject.RemoveSocket(m_s);
                 m_handleValid = false;
 
-                try {
+                try
+                {
                     m_s.NoDelay = true;
-                } catch (ArgumentException) {
+                }
+                catch (ArgumentException)
+                {
                     // OSX sometime fail while the socket is still connecting
                 }
 
@@ -259,7 +262,16 @@ public void OutCompleted(SocketError socketError, int bytesTransferred)
                         bytes.PutInteger(endian, m_options.TcpKeepaliveIdle, 4);
                         bytes.PutInteger(endian, m_options.TcpKeepaliveIntvl, 8);
 
+                        bytes.PutInteger(endian, m_options.TcpKeepaliveIntvl, 8);
+#if NET
+                        if (!OperatingSystem.IsWindows())
+                        {
+                            throw new InvalidOperationException("Not supported on you platform"); // There is a pull request for .net8.0
+
+                        }
+#endif
                         m_s.IOControl(IOControlCode.KeepAliveValues, (byte[])bytes, null);
+
                     }
                 }
 
diff --git a/src/NetMQ/Core/Transports/Tcp/TcpListener.cs b/src/NetMQ/Core/Transports/Tcp/TcpListener.cs
@@ -45,12 +45,12 @@ internal class TcpListener : Own, IProactorEvents
         /// </summary>
         private AsyncSocket? m_handle;
 
-/*
-        /// <summary>
-        /// socket being accepted
-        /// </summary>
-        private AsyncSocket m_acceptedSocket;
-*/
+        /*
+                /// <summary>
+                /// socket being accepted
+                /// </summary>
+                private AsyncSocket m_acceptedSocket;
+        */
 
         /// <summary>
         /// Socket the listener belongs to.
@@ -107,7 +107,7 @@ protected override void ProcessPlug()
         protected override void ProcessTerm(int linger)
         {
             Assumes.NotNull(m_handle);
-           
+
             m_ioObject.SetHandler(this);
             m_ioObject.RemoveSocket(m_handle);
             Close();
@@ -123,7 +123,7 @@ public virtual void SetAddress(string addr)
             m_address.Resolve(addr, m_options.IPv4Only);
 
             Assumes.NotNull(m_address.Address);
-           
+
 
             try
             {
@@ -195,68 +195,75 @@ public void InCompleted(SocketError socketError, int bytesTransferred)
             switch (socketError)
             {
                 case SocketError.Success:
-                {
-                    // TODO: check TcpFilters
-                    var acceptedSocket = m_handle.GetAcceptedSocket();
+                    {
+                        // TODO: check TcpFilters
+                        var acceptedSocket = m_handle.GetAcceptedSocket();
 
                         acceptedSocket.NoDelay = true;
 
-                    if (m_options.TcpKeepalive != -1)
-                    {
-                        acceptedSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, m_options.TcpKeepalive);
-
-                        if (m_options.TcpKeepaliveIdle != -1 && m_options.TcpKeepaliveIntvl != -1)
+                        if (m_options.TcpKeepalive != -1)
                         {
-                            var bytes = new ByteArraySegment(new byte[12]);
+                            acceptedSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, m_options.TcpKeepalive);
+
+                            if (m_options.TcpKeepaliveIdle != -1 && m_options.TcpKeepaliveIntvl != -1)
+                            {
+                                var bytes = new ByteArraySegment(new byte[12]);
+
+                                Endianness endian = BitConverter.IsLittleEndian ? Endianness.Little : Endianness.Big;
 
-                            Endianness endian = BitConverter.IsLittleEndian ? Endianness.Little : Endianness.Big;
+                                bytes.PutInteger(endian, m_options.TcpKeepalive, 0);
+                                bytes.PutInteger(endian, m_options.TcpKeepaliveIdle, 4);
+                                bytes.PutInteger(endian, m_options.TcpKeepaliveIntvl, 8);
+#if NET
+                                if (!OperatingSystem.IsWindows())
+                                {
+                                    throw new InvalidOperationException("Not supported on you platform"); // There is a pull request for .net8.0
 
-                            bytes.PutInteger(endian, m_options.TcpKeepalive, 0);
-                            bytes.PutInteger(endian, m_options.TcpKeepaliveIdle, 4);
-                            bytes.PutInteger(endian, m_options.TcpKeepaliveIntvl, 8);
+                                }
+#endif
+                                acceptedSocket.IOControl(IOControlCode.KeepAliveValues, (byte[])bytes, null);
 
-                            acceptedSocket.IOControl(IOControlCode.KeepAliveValues, (byte[])bytes, null);
+                            }
                         }
-                    }
 
-                    // Create the engine object for this connection.
-                    var engine = new StreamEngine(acceptedSocket, m_options, m_endpoint);
+                        // Create the engine object for this connection.
+                        var engine = new StreamEngine(acceptedSocket, m_options, m_endpoint);
 
-                    // Choose I/O thread to run connector in. Given that we are already
-                    // running in an I/O thread, there must be at least one available.
-                    IOThread? ioThread = ChooseIOThread(m_options.Affinity);
+                        // Choose I/O thread to run connector in. Given that we are already
+                        // running in an I/O thread, there must be at least one available.
+                        IOThread? ioThread = ChooseIOThread(m_options.Affinity);
 
-                    Assumes.NotNull(ioThread);
+                        Assumes.NotNull(ioThread);
 
-                    // Create and launch a session object.
-                    // TODO: send null in address parameter, is unneeded in this case
-                    SessionBase session = SessionBase.Create(ioThread, false, m_socket, m_options, new Address(m_handle.LocalEndPoint));
-                    session.IncSeqnum();
-                    LaunchChild(session);
+                        // Create and launch a session object.
+                        // TODO: send null in address parameter, is unneeded in this case
+                        SessionBase session = SessionBase.Create(ioThread, false, m_socket, m_options, new Address(m_handle.LocalEndPoint));
+                        session.IncSeqnum();
+                        LaunchChild(session);
 
-                    SendAttach(session, engine, false);
+                        SendAttach(session, engine, false);
 
-                    m_socket.EventAccepted(m_endpoint, acceptedSocket);
+                        m_socket.EventAccepted(m_endpoint, acceptedSocket);
 
-                    Accept();
-                    break;
-                }
+                        Accept();
+                        break;
+                    }
                 case SocketError.ConnectionReset:
                 case SocketError.NoBufferSpaceAvailable:
                 case SocketError.TooManyOpenSockets:
-                {
-                    m_socket.EventAcceptFailed(m_endpoint, socketError.ToErrorCode());
+                    {
+                        m_socket.EventAcceptFailed(m_endpoint, socketError.ToErrorCode());
 
-                    Accept();
-                    break;
-                }
+                        Accept();
+                        break;
+                    }
                 default:
-                {
-                    NetMQException exception = NetMQException.Create(socketError);
+                    {
+                        NetMQException exception = NetMQException.Create(socketError);
 
-                    m_socket.EventAcceptFailed(m_endpoint, exception.ErrorCode);
-                    throw exception;
-                }
+                        m_socket.EventAcceptFailed(m_endpoint, exception.ErrorCode);
+                        throw exception;
+                    }
             }
         }
 
diff --git a/src/NetMQ/Core/Utils/OpCode.cs b/src/NetMQ/Core/Utils/OpCode.cs
diff --git a/src/NetMQ/NetMQSynchronizationContext.cs b/src/NetMQ/NetMQSynchronizationContext.cs

Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ public void Issue52_ReqToRouterBug()`
`128`	`128`
`129`	`129`	`var msg = router.ReceiveMultipartMessage();`
`130`	`130`	`Assert.Equal(3, msg.FrameCount);`
`131`		`- Assert.Equal(msg[2].ConvertToString(), testmessage);`
	`131`	`+ Assert.Equal(testmessage, msg[2].ConvertToString());`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
Original file line number	Diff line number	Diff line change
`@@ -57,9 +57,9 @@ public void Monitoring()`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`-#if !NET35`
	`60`	`+`
`61`	`61`	`[Fact]`
`62`		`- public void StartAsync()`
	`62`	`+ public async Task StartAsync()`
`63`	`63`	`{`
`64`	`64`	`using (var rep = new ResponseSocket())`
`65`	`65`	`using (var monitor = new NetMQMonitor(rep, "inproc://foo", SocketEvents.Closed))`
`@@ -68,10 +68,11 @@ public void StartAsync()`
`68`	`68`	`Thread.Sleep(200);`
`69`	`69`	`Assert.Equal(TaskStatus.Running, task.Status);`
`70`	`70`	`monitor.Stop();`
`71`		`- Assert.True(task.Wait(TimeSpan.FromMilliseconds(1000)));`
	`71`	`+ var completedTask = await Task.WhenAny(task, Task.Delay(1000));`
	`72`	`+ Assert.Equal(task, completedTask);`
`72`	`73`	`}`
`73`	`74`	`}`
`74`		`-#endif`
	`75`	`+`
`75`	`76`
`76`	`77`	`[Fact]`
`77`	`78`	`public void NoHangWhenMonitoringUnboundInprocAddress()`
`@@ -126,7 +127,7 @@ public void ErrorCodeTest()`
`126`	`127`	`}`
`127`	`128`
`128`	`129`	`[Fact]`
`129`		`- public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()`
	`130`	`+ public async Task MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()`
`130`	`131`	`{`
`131`	`132`	`// The bug:`
`132`	`133`	`// Given we monitor a netmq tcp socket`
`@@ -141,7 +142,7 @@ public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()`
`141`	`142`	`using (var req = new RequestSocket())`
`142`	`143`	`{`
`143`	`144`	`monitor = new NetMQMonitor(req, "inproc://#monitor", SocketEvents.All);`
`144`		`- Task.Factory.StartNew(monitor.Start);`
	`145`	`+ _ = Task.Factory.StartNew(monitor.Start);`
`145`	`146`
`146`	`147`	`// Bug only occurs when monitoring a tcp socket`
`147`	`148`	`var port = res.BindRandomPort("tcp://127.0.0.1");`
`@@ -152,10 +153,12 @@ public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()`
`152`	`153`	`res.SendFrame("response");`
`153`	`154`	`Assert.Equal("response", req.ReceiveFrameString());`
`154`	`155`	`}`
`155`		`- Thread.Sleep(100);`
	`156`	`+`
	`157`	`+ await Task.Delay(100);`
`156`	`158`	`// Monitor.Dispose should complete`
`157`		`- var completed = Task.Factory.StartNew(() => monitor.Dispose()).Wait(1000);`
`158`		`- Assert.True(completed);`
	`159`	`+ var task = Task.Factory.StartNew(() => monitor.Dispose());`
	`160`	`+ var completedTask = await Task.WhenAny(task, Task.Delay(1000));`
	`161`	`+ Assert.Equal(task, completedTask);`
`159`	`162`	`}`
`160`	`163`	`// NOTE If this test fails, it will hang because context.Dispose will block`
`161`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`
`11`	`11`	`#if !NET35`
`12`	`12`	`using System.Collections.Concurrent;`
	`13`	`+using System.Collections.Generic;`
`13`	`14`	`#endif`
`14`	`15`
`15`	`16`	`// ReSharper disable AccessToDisposedClosure`
`@@ -865,7 +866,7 @@ public void NativeSocket()`
`865`	`866`
`866`	`867`	`#if !NET35`
`867`	`868`	`[Fact]`
`868`		`- public void OneTask()`
	`869`	`+ public async Task OneTask()`
`869`	`870`	`{`
`870`	`871`	`bool triggered = false;`
`871`	`872`
`@@ -879,27 +880,27 @@ public void OneTask()`
`879`	`880`	`Assert.True(poller.CanExecuteTaskInline, "Should be on NetMQPoller thread");`
`880`	`881`	`});`
`881`	`882`	`task.Start(poller);`
`882`		`- task.Wait();`
	`883`	`+ await task;`
`883`	`884`
`884`	`885`	`Assert.True(triggered);`
`885`	`886`	`}`
`886`	`887`	`}`
`887`	`888`
`888`	`889`	`[Fact]`
`889`		`- public void SetsCurrentTaskScheduler()`
	`890`	`+ public async Task SetsCurrentTaskScheduler()`
`890`	`891`	`{`
`891`	`892`	`using (var poller = new NetMQPoller())`
`892`	`893`	`{`
`893`	`894`	`poller.RunAsync();`
`894`	`895`
`895`	`896`	`var task = new Task(() => Assert.Same(TaskScheduler.Current, poller));`
`896`	`897`	`task.Start(poller);`
`897`		`- task.Wait();`
	`898`	`+ await task;`
`898`	`899`	`}`
`899`	`900`	`}`
`900`	`901`
`901`	`902`	`[Fact]`
`902`		`- public void CanExecuteTaskInline()`
	`903`	`+ public async Task CanExecuteTaskInline()`
`903`	`904`	`{`
`904`	`905`	`using (var poller = new NetMQPoller())`
`905`	`906`	`{`
`@@ -911,12 +912,12 @@ public void CanExecuteTaskInline()`
`911`	`912`
`912`	`913`	`var task = new Task(() => Assert.True(poller.CanExecuteTaskInline));`
`913`	`914`	`task.Start(poller);`
`914`		`- task.Wait();`
	`915`	`+ await task;`
`915`	`916`	`}`
`916`	`917`	`}`
`917`	`918`
`918`	`919`	`[Fact]`
`919`		`- public void ContinueWith()`
	`920`	`+ public async Task ContinueWith()`
`920`	`921`	`{`
`921`	`922`	`int threadId1 = 0;`
`922`	`923`	`int threadId2 = 1;`
`@@ -941,8 +942,7 @@ public void ContinueWith()`
`941`	`942`	`}, poller);`
`942`	`943`
`943`	`944`	`task.Start(poller);`
`944`		`- task.Wait();`
`945`		`- task2.Wait();`
	`945`	`+ await Task.WhenAll(new List<Task>{task, task2});`
`946`	`946`
`947`	`947`	`Assert.Equal(threadId1, threadId2);`
`948`	`948`	`Assert.Equal(1, runCount1);`
`@@ -951,7 +951,7 @@ public void ContinueWith()`
`951`	`951`	`}`
`952`	`952`
`953`	`953`	`[Fact]`
`954`		`- public void TwoThreads()`
	`954`	`+ public async Task TwoThreads()`
`955`	`955`	`{`
`956`	`956`	`int count1 = 0;`
`957`	`957`	`int count2 = 0;`
`@@ -982,9 +982,8 @@ public void TwoThreads()`
`982`	`982`	`}`
`983`	`983`	`});`
`984`	`984`
`985`		`- t1.Wait(1000);`
`986`		`- t2.Wait(1000);`
`987`		`- Task.WaitAll(allTasks.ToArray(), 1000);`
	`985`	`+ await Task.WhenAny(Task.WhenAll(new List<Task>{ t1, t2 }), Task.Delay(1000));`
	`986`	`+ await Task.WhenAny(Task.WhenAll(allTasks.ToArray()), Task.Delay(1000));`
`988`	`987`
`989`	`988`	`Assert.Equal(100, count1);`
`990`	`989`	`Assert.Equal(100, count2);`