Merge pull request #887 from drewnoakes/more-annotations

Annotate internal patterns, utils and some public API

Author: drewnoakes

src/NetMQ.Tests/MsgTests.cs

@@ -25,7 +25,7 @@ public void Constructor()
             Assert.False(msg.IsDelimiter);
             Assert.False(msg.IsIdentity);
             Assert.False(msg.IsInitialised);
-            Assert.Throws<NullReferenceException>(() => msg[0] = 1);
+            Assert.ThrowsAny<Exception>(() => msg[0] = 1);
             Assert.Throws<FaultException>((Action)msg.Close);
         }
 

src/NetMQ/Core/Address.cs

@@ -18,10 +18,7 @@ You should have received a copy of the GNU Lesser General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#nullable disable
-
 using System.Net;
-using JetBrains.Annotations;
 
 namespace NetMQ.Core
 {
@@ -65,18 +62,18 @@ internal sealed class Address
         /// </summary>
         public interface IZAddress
         {
-            void Resolve([NotNull] string name, bool ip4Only);
+            void Resolve(string name, bool ip4Only);
 
-            [CanBeNull] IPEndPoint Address { get; }
-            [NotNull] string Protocol { get; }
+            IPEndPoint? Address { get; }
+            string Protocol { get; }
         }
 
         /// <summary>
         /// Create a new Address instance with the given protocol and text expression of an address.
         /// </summary>
         /// <param name="protocol">the protocol of this Address - as in tcp, ipc, pgm</param>
         /// <param name="address">a text representation of the address</param>
-        public Address([NotNull] string protocol, [NotNull] string address)
+        public Address(string protocol, string address)
         {
             Protocol = protocol;
             AddressString = address;
@@ -87,7 +84,7 @@ public Address([NotNull] string protocol, [NotNull] string address)
         /// Create a new Address instance based upon the given endpoint, assuming a protocol of tcp.
         /// </summary>
         /// <param name="endpoint">the subclass of EndPoint to base this Address upon</param>
-        public Address([NotNull] EndPoint endpoint)
+        public Address(EndPoint endpoint)
         {
             Protocol = TcpProtocol;
 
@@ -126,16 +123,13 @@ public override string ToString()
                 return Protocol + "://" + AddressString;
             }
 
-            return null; //TODO: REVIEW - Although not explicitly prohibited, returning null from ToString seems sketchy; return string.Empty?
+            return base.ToString();
         }
 
-        [NotNull]
         public string Protocol { get; }
 
-        [NotNull]
         public string AddressString { get; }
 
-        [CanBeNull]
-        public IZAddress Resolved { get; set; }
+        public IZAddress? Resolved { get; set; }
     }
 }

src/NetMQ/Core/Command.cs

@@ -19,10 +19,6 @@ You should have received a copy of the GNU Lesser General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#nullable disable
-
-using JetBrains.Annotations;
-
 namespace NetMQ.Core
 {
     /// <summary>
@@ -36,25 +32,23 @@ internal struct Command
         /// <param name="destination">a ZObject that denotes the destination for this command</param>
         /// <param name="type">the CommandType of the new command</param>
         /// <param name="arg">an Object to comprise the argument for the command (optional)</param>
-        public Command([CanBeNull] ZObject destination, CommandType type, [CanBeNull] object arg = null) : this()
+        public Command(ZObject? destination, CommandType type, object? arg = null) : this()
         {
             Destination = destination;
             CommandType = type;
             Arg = arg;
         }
 
         /// <summary>The destination to which the command should be applied.</summary>
-        [CanBeNull]
-        public ZObject Destination { get; }
+        public ZObject? Destination { get; }
 
         /// <summary>The type of this command.</summary>
         public CommandType CommandType { get; }
 
         /// <summary>
         /// Get the argument to this command.
         /// </summary>
-        [CanBeNull]
-        public object Arg { get; }
+        public object? Arg { get; }
 
         /// <summary>
         /// Override of ToString, which returns a string in the form [ command-type, destination ].

src/NetMQ/Core/CommandType.cs

@@ -1,5 +1,3 @@
-#nullable disable
-
 namespace NetMQ.Core
 {
     /// <summary>

src/NetMQ/Core/Config.cs

@@ -19,8 +19,6 @@ You should have received a copy of the GNU Lesser General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#nullable disable
-
 namespace NetMQ.Core
 {
     /// <summary>

src/NetMQ/Core/ErrorHelper.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-using System.Diagnostics;
+using System.Diagnostics;
 using System.Net.Sockets;
 
 namespace NetMQ.Core

src/NetMQ/Core/HellloMsgSession.cs

@@ -1,14 +1,10 @@
-#nullable disable
-
-using JetBrains.Annotations;
-
 namespace NetMQ.Core
 {
     class HelloMsgSession : SessionBase
     {
         bool m_newPipe;
 
-        public HelloMsgSession([NotNull] IOThread ioThread, bool connect, [NotNull] SocketBase socket, [NotNull] Options options, [NotNull] Address addr) : 
+        public HelloMsgSession(IOThread ioThread, bool connect, SocketBase socket, Options options, Address addr) : 
             base(ioThread, connect, socket, options, addr)
         {
             m_newPipe = true;
@@ -18,6 +14,8 @@ public override PullMsgResult PullMsg(ref Msg msg)
         {
             if (m_newPipe)
             {
+                Assumes.NotNull(m_options.HelloMsg);
+
                 m_newPipe = false;
                 msg.InitPool(m_options.HelloMsg.Length);
                 msg.Put(m_options.HelloMsg, 0, m_options.HelloMsg.Length);

src/NetMQ/Core/IMailbox.cs

@@ -1,12 +1,8 @@
-#nullable disable
-
-using JetBrains.Annotations;
-
 namespace NetMQ.Core
 {
     internal interface IMailbox
     {
-        void Send([NotNull] Command command);
+        void Send(Command command);
 
         bool TryRecv(int timeout, out Command command);
 

src/NetMQ/Core/IOObject.cs

@@ -19,12 +19,9 @@ You should have received a copy of the GNU Lesser General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#nullable disable
-
 using System.Diagnostics;
 using System.Net.Sockets;
 using AsyncIO;
-using JetBrains.Annotations;
 
 namespace NetMQ.Core
 {
@@ -35,16 +32,14 @@ namespace NetMQ.Core
     /// </summary>
     internal class IOObject : IProactorEvents
     {
-        [CanBeNull]
-        private IOThread m_ioThread;
-        [CanBeNull]
-        private IProactorEvents m_handler;
+        private IOThread? m_ioThread;
+        private IProactorEvents? m_handler;
 
         /// <summary>
         /// Create a new IOObject object and plug it into the given IOThread.
         /// </summary>
         /// <param name="ioThread">the IOThread to plug this new IOObject into.</param>
-        public IOObject([CanBeNull] IOThread ioThread)
+        public IOObject(IOThread? ioThread)
         {
             if (ioThread != null)
                 Plug(ioThread);
@@ -58,7 +53,7 @@ public IOObject([CanBeNull] IOThread ioThread)
         /// When migrating an object from one I/O thread to another, first
         /// unplug it, then migrate it, then plug it to the new thread.
         /// </remarks>
-        public void Plug([NotNull] IOThread ioThread)
+        public void Plug(IOThread ioThread)
         {
             Debug.Assert(ioThread != null);
 
@@ -74,7 +69,7 @@ public void Plug([NotNull] IOThread ioThread)
         /// </remarks>
         public void Unplug()
         {
-            Debug.Assert(m_ioThread != null);
+            Assumes.NotNull(m_ioThread);
 
             // Forget about old poller in preparation to be migrated
             // to a different I/O thread.
@@ -86,17 +81,19 @@ public void Unplug()
         /// Add the given socket to the Proactor.
         /// </summary>
         /// <param name="socket">the AsyncSocket to add</param>
-        public void AddSocket([NotNull] AsyncSocket socket)
+        public void AddSocket(AsyncSocket socket)
         {
+            Assumes.NotNull(m_ioThread);
             m_ioThread.Proactor.AddSocket(socket, this);
         }
 
         /// <summary>
         /// Remove the given socket from the Proactor.
         /// </summary>
         /// <param name="socket">the AsyncSocket to remove</param>
-        public void RemoveSocket([NotNull] AsyncSocket socket)
+        public void RemoveSocket(AsyncSocket socket)
         {
+            Assumes.NotNull(m_ioThread);
             m_ioThread.Proactor.RemoveSocket(socket);
         }
 
@@ -107,6 +104,7 @@ public void RemoveSocket([NotNull] AsyncSocket socket)
         /// <param name="bytesTransferred">the number of bytes that were transferred</param>
         public virtual void InCompleted(SocketError socketError, int bytesTransferred)
         {
+            Assumes.NotNull(m_handler);
             m_handler.InCompleted(socketError, bytesTransferred);
         }
 
@@ -117,6 +115,7 @@ public virtual void InCompleted(SocketError socketError, int bytesTransferred)
         /// <param name="bytesTransferred">the number of bytes that were transferred</param>
         public virtual void OutCompleted(SocketError socketError, int bytesTransferred)
         {
+            Assumes.NotNull(m_handler);
             m_handler.OutCompleted(socketError, bytesTransferred);
         }
 
@@ -126,21 +125,24 @@ public virtual void OutCompleted(SocketError socketError, int bytesTransferred)
         /// <param name="id">an integer used to identify the timer</param>
         public virtual void TimerEvent(int id)
         {
+            Assumes.NotNull(m_handler);
             m_handler.TimerEvent(id);
         }
 
         public void AddTimer(long timeout, int id)
         {
+            Assumes.NotNull(m_ioThread);
             m_ioThread.Proactor.AddTimer(timeout, this, id);
         }
 
-        public void SetHandler([NotNull] IProactorEvents handler)
+        public void SetHandler(IProactorEvents handler)
         {
             m_handler = handler;
         }
 
         public void CancelTimer(int id)
         {
+            Assumes.NotNull(m_ioThread);
             m_ioThread.Proactor.CancelTimer(this, id);
         }
     }

src/NetMQ/Core/IOThread.cs

@@ -19,9 +19,6 @@ You should have received a copy of the GNU Lesser General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#nullable disable
-
-using JetBrains.Annotations;
 using NetMQ.Core.Utils;
 
 namespace NetMQ.Core
@@ -50,7 +47,7 @@ internal sealed class IOThread : ZObject, IMailboxEvent
         /// </summary>
         /// <param name="ctx">the Ctx (context) for this thread to live within</param>
         /// <param name="threadId">the integer thread-id for this new IOThread</param>
-        public IOThread([NotNull] Ctx ctx, int threadId)
+        public IOThread(Ctx ctx, int threadId)
             : base(ctx, threadId)
         {
             var name = "iothread-" + threadId;
@@ -62,7 +59,6 @@ public IOThread([NotNull] Ctx ctx, int threadId)
 #endif
         }
 
-        [NotNull]
         internal Proactor Proactor => m_proactor;
 
         public void Start()
@@ -81,7 +77,6 @@ public void Stop()
             SendStop();
         }
 
-        [NotNull]
         public IMailbox Mailbox => m_mailbox;
 
         public int Load => m_proactor.Load;
@@ -95,7 +90,10 @@ public void Ready()
         {
             // Process all available commands.
             while (m_mailbox.TryRecv(out Command command))
+            {
+                Assumes.NotNull(command.Destination);
                 command.Destination.ProcessCommand(command);
+            }
         }
 
 #if DEBUG