make mirror on github.com

LICENSE

@@ -0,0 +1,203 @@
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
+LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
+CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation
+   distributed under this Agreement, and
+b) in the case of each subsequent Contributor:
+    i) changes to the Program, and
+   ii) additions to the Program;
+
+   where such changes and/or additions to the Program originate from and are
+   distributed by that particular Contributor. A Contribution 'originates'
+   from a Contributor if it was added to the Program by such Contributor
+   itself or anyone acting on such Contributor's behalf. Contributions do not
+   include additions to the Program which: (i) are separate modules of
+   software distributed in conjunction with the Program under their own
+   license agreement, and (ii) are not derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+  a) Subject to the terms of this Agreement, each Contributor hereby grants
+     Recipient a non-exclusive, worldwide, royalty-free copyright license to
+     reproduce, prepare derivative works of, publicly display, publicly
+     perform, distribute and sublicense the Contribution of such Contributor,
+     if any, and such derivative works, in source code and object code form.
+  b) Subject to the terms of this Agreement, each Contributor hereby grants
+     Recipient a non-exclusive, worldwide, royalty-free patent license under
+     Licensed Patents to make, use, sell, offer to sell, import and otherwise
+     transfer the Contribution of such Contributor, if any, in source code and
+     object code form. This patent license shall apply to the combination of
+     the Contribution and the Program if, at the time the Contribution is
+     added by the Contributor, such addition of the Contribution causes such
+     combination to be covered by the Licensed Patents. The patent license
+     shall not apply to any other combinations which include the Contribution.
+     No hardware per se is licensed hereunder.
+  c) Recipient understands that although each Contributor grants the licenses
+     to its Contributions set forth herein, no assurances are provided by any
+     Contributor that the Program does not infringe the patent or other
+     intellectual property rights of any other entity. Each Contributor
+     disclaims any liability to Recipient for claims brought by any other
+     entity based on infringement of intellectual property rights or
+     otherwise. As a condition to exercising the rights and licenses granted
+     hereunder, each Recipient hereby assumes sole responsibility to secure
+     any other intellectual property rights needed, if any. For example, if a
+     third party patent license is required to allow Recipient to distribute
+     the Program, it is Recipient's responsibility to acquire that license
+     before distributing the Program.
+  d) Each Contributor represents that to its knowledge it has sufficient
+     copyright rights in its Contribution, if any, to grant the copyright
+     license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under
+its own license agreement, provided that:
+
+  a) it complies with the terms and conditions of this Agreement; and
+  b) its license agreement:
+      i) effectively disclaims on behalf of all Contributors all warranties
+         and conditions, express and implied, including warranties or
+         conditions of title and non-infringement, and implied warranties or
+         conditions of merchantability and fitness for a particular purpose;
+     ii) effectively excludes on behalf of all Contributors all liability for
+         damages, including direct, indirect, special, incidental and
+         consequential damages, such as lost profits;
+    iii) states that any provisions which differ from this Agreement are
+         offered by that Contributor alone and not by any other party; and
+     iv) states that source code for the Program is available from such
+         Contributor, and informs licensees how to obtain it in a reasonable
+         manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+  a) it must be made available under this Agreement; and
+  b) a copy of this Agreement must be included with each copy of the Program.
+     Contributors may not remove or alter any copyright notices contained
+     within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution,
+if
+any, in a manner that reasonably allows subsequent Recipients to identify the
+originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with
+respect to end users, business partners and the like. While this license is
+intended to facilitate the commercial use of the Program, the Contributor who
+includes the Program in a commercial product offering should do so in a manner
+which does not create potential liability for other Contributors. Therefore,
+if a Contributor includes the Program in a commercial product offering, such
+Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
+every other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits and
+other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such Commercial
+Contributor in connection with its distribution of the Program in a commercial
+product offering. The obligations in this section do not apply to any claims
+or Losses relating to any actual or alleged intellectual property
+infringement. In order to qualify, an Indemnified Contributor must:
+a) promptly notify the Commercial Contributor in writing of such claim, and
+b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement
+negotiations. The Indemnified Contributor may participate in any such claim at
+its own expense.
+
+For example, a Contributor might include the Program in a commercial product
+offering, Product X. That Contributor is then a Commercial Contributor. If
+that Commercial Contributor then makes performance claims, or offers
+warranties related to Product X, those performance claims and warranties are
+such Commercial Contributor's responsibility alone. Under this section, the
+Commercial Contributor would have to defend claims against the other
+Contributors related to those performance claims and warranties, and if a
+court requires any other Contributor to pay any damages as a result, the
+Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
+Recipient is solely responsible for determining the appropriateness of using
+and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the
+risks and costs of program errors, compliance with applicable laws, damage to
+or loss of data, programs or equipment, and unavailability or interruption of
+operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
+LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of the
+remainder of the terms of this Agreement, and without further action by the
+parties hereto, such provision shall be reformed to the minimum extent
+necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+(excluding combinations of the Program with other software or hardware)
+infringes such Recipient's patent(s), then such Recipient's rights granted
+under Section 2(b) shall terminate as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to
+comply with any of the material terms or conditions of this Agreement and does
+not cure such failure in a reasonable period of time after becoming aware of
+such noncompliance. If all Recipient's rights under this Agreement terminate,
+Recipient agrees to cease use and distribution of the Program as soon as
+reasonably practicable. However, Recipient's obligations under this Agreement
+and any licenses granted by Recipient relating to the Program shall continue
+and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in
+order to avoid inconsistency the Agreement is copyrighted and may only be
+modified in the following manner. The Agreement Steward reserves the right to
+publish new versions (including revisions) of this Agreement from time to
+time. No one other than the Agreement Steward has the right to modify this
+Agreement. The Eclipse Foundation is the initial Agreement Steward. The
+Eclipse Foundation may assign the responsibility to serve as the Agreement
+Steward to a suitable separate entity. Each new version of the Agreement will
+be given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version of the
+Agreement is published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as expressly
+stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
+licenses to the intellectual property of any Contributor under this Agreement,
+whether expressly, by implication, estoppel or otherwise. All rights in the
+Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the
+intellectual property laws of the United States of America. No party to this
+Agreement will bring a legal action under this Agreement more than one year
+after the cause of action arose. Each party waives its rights to a jury trial in
+any resulting litigation.

M2Mqtt.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29519.87
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "M2Mqtt", "M2Mqtt\M2Mqtt.csproj", "{18F706D2-7610-428C-8324-8327F9D7BE90}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{18F706D2-7610-428C-8324-8327F9D7BE90}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{18F706D2-7610-428C-8324-8327F9D7BE90}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{18F706D2-7610-428C-8324-8327F9D7BE90}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{18F706D2-7610-428C-8324-8327F9D7BE90}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {EBFDF320-2C59-4F89-8211-5B6EF9C310ED}
+	EndGlobalSection
+EndGlobal

M2Mqtt/Exceptions/MqttClientException.cs

@@ -16,117 +16,104 @@ Contributors:
 
 using System;
 
-namespace uPLibrary.Networking.M2Mqtt.Exceptions
+namespace uPLibrary.Networking.M2Mqtt.Exceptions {
-{
+  /// <summary>
+  /// MQTT client exception
+  /// </summary>
+  public class MqttClientException : Exception {
     /// <summary>
-    /// MQTT client exception
+    /// Constructor
     /// </summary>
-    public class MqttClientException : Exception
+    /// <param name="code">Error code</param>
-    {
+    public MqttClientException(MqttClientErrorCode errorCode) => this.ErrorCode = errorCode;
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="code">Error code</param>
-        public MqttClientException(MqttClientErrorCode errorCode)
-        {
-            this.errorCode = errorCode;
-        }
-
-        // error code
-        private MqttClientErrorCode errorCode;
-
-        /// <summary>
-        /// Error code
-        /// </summary>
-        public MqttClientErrorCode ErrorCode
-        {
-            get { return this.errorCode; }
-            set { this.errorCode = value; }
-        }
-    }
 
     /// <summary>
-    /// MQTT client erroro code
+    /// Error code
     /// </summary>
-    public enum MqttClientErrorCode
+    public MqttClientErrorCode ErrorCode { get; set; }
-    {
+  }
-        /// <summary>
-        /// Will error (topic, message or QoS level)
-        /// </summary>
-        WillWrong = 1,
 
-        /// <summary>
+  /// <summary>
-        /// Keep alive period too large
+  /// MQTT client erroro code
-        /// </summary>
+  /// </summary>
-        KeepAliveWrong,
+  public enum MqttClientErrorCode {
+    /// <summary>
+    /// Will error (topic, message or QoS level)
+    /// </summary>
+    WillWrong = 1,
 
-        /// <summary>
+    /// <summary>
-        /// Topic contains wildcards
+    /// Keep alive period too large
-        /// </summary>
+    /// </summary>
-        TopicWildcard,
+    KeepAliveWrong,
 
-        /// <summary>
+    /// <summary>
-        /// Topic length wrong
+    /// Topic contains wildcards
-        /// </summary>
+    /// </summary>
-        TopicLength,
+    TopicWildcard,
 
-        /// <summary>
+    /// <summary>
-        /// QoS level not allowed
+    /// Topic length wrong
-        /// </summary>
+    /// </summary>
-        QosNotAllowed,
+    TopicLength,
 
-        /// <summary>
+    /// <summary>
-        /// Topics list empty for subscribe
+    /// QoS level not allowed
-        /// </summary>
+    /// </summary>
-        TopicsEmpty,
+    QosNotAllowed,
 
-        /// <summary>
+    /// <summary>
-        /// Qos levels list empty for subscribe
+    /// Topics list empty for subscribe
-        /// </summary>
+    /// </summary>
-        QosLevelsEmpty,
+    TopicsEmpty,
 
-        /// <summary>
+    /// <summary>
-        /// Topics / Qos Levels not match in subscribe
+    /// Qos levels list empty for subscribe
-        /// </summary>
+    /// </summary>
-        TopicsQosLevelsNotMatch,
+    QosLevelsEmpty,
 
-        /// <summary>
+    /// <summary>
-        /// Wrong message from broker
+    /// Topics / Qos Levels not match in subscribe
-        /// </summary>
+    /// </summary>
-        WrongBrokerMessage,
+    TopicsQosLevelsNotMatch,
 
-        /// <summary>
+    /// <summary>
-        /// Wrong Message Id
+    /// Wrong message from broker
-        /// </summary>
+    /// </summary>
-        WrongMessageId,
+    WrongBrokerMessage,
 
-        /// <summary>
+    /// <summary>
-        /// Inflight queue is full
+    /// Wrong Message Id
-        /// </summary>
+    /// </summary>
-        InflightQueueFull,
+    WrongMessageId,
 
-        // [v3.1.1]
+    /// <summary>
-        /// <summary>
+    /// Inflight queue is full
-        /// Invalid flag bits received 
+    /// </summary>
-        /// </summary>
+    InflightQueueFull,
-        InvalidFlagBits,
 
-        // [v3.1.1]
+    // [v3.1.1]
-        /// <summary>
+    /// <summary>
-        /// Invalid connect flags received
+    /// Invalid flag bits received 
-        /// </summary>
+    /// </summary>
-        InvalidConnectFlags,
+    InvalidFlagBits,
 
-        // [v3.1.1]
+    // [v3.1.1]
-        /// <summary>
+    /// <summary>
-        /// Invalid client id
+    /// Invalid connect flags received
-        /// </summary>
+    /// </summary>
-        InvalidClientId,
+    InvalidConnectFlags,
 
-        // [v3.1.1]
+    // [v3.1.1]
-        /// <summary>
+    /// <summary>
-        /// Invalid protocol name
+    /// Invalid client id
-        /// </summary>
+    /// </summary>
-        InvalidProtocolName
+    InvalidClientId,
-    }
+
+    // [v3.1.1]
+    /// <summary>
+    /// Invalid protocol name
+    /// </summary>
+    InvalidProtocolName
+  }
 }

M2Mqtt/Exceptions/MqttCommunicationException.cs

@@ -16,27 +16,23 @@ Contributors:
 
 using System;
 
-namespace uPLibrary.Networking.M2Mqtt.Exceptions
+namespace uPLibrary.Networking.M2Mqtt.Exceptions {
-{
+  /// <summary>
+  /// Exception due to error communication with broker on socket
+  /// </summary>
+  public class MqttCommunicationException : Exception {
     /// <summary>
-    /// Exception due to error communication with broker on socket
+    /// Default constructor
     /// </summary>
-    public class MqttCommunicationException : Exception
+    public MqttCommunicationException() {
-    {
-        /// <summary>
-        /// Default constructor
-        /// </summary>
-        public MqttCommunicationException()
-        {
-        }
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="e">Inner Exception</param>
-        public MqttCommunicationException(Exception e)
-            : base(String.Empty, e)
-        {
-        }
     }
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="e">Inner Exception</param>
+    public MqttCommunicationException(Exception e)
+        : base(String.Empty, e) {
+    }
+  }
 }

M2Mqtt/Exceptions/MqttConnectionException.cs

@@ -16,16 +16,13 @@ Contributors:
 
 using System;
 
-namespace uPLibrary.Networking.M2Mqtt.Exceptions
+namespace uPLibrary.Networking.M2Mqtt.Exceptions {
-{
+  /// <summary>
-    /// <summary>
+  /// Connection to the broker exception
-    /// Connection to the broker exception
+  /// </summary>
-    /// </summary>
+  public class MqttConnectionException : Exception {
-    public class MqttConnectionException : Exception
+    public MqttConnectionException(String message, Exception innerException)
-    {
+        : base(message, innerException) {
-        public MqttConnectionException(string message, Exception innerException)
-            : base(message, innerException)
-        {
-        }
     }
+  }
 }

M2Mqtt/Exceptions/MqttTimeoutException.cs

@@ -16,12 +16,10 @@ Contributors:
 
 using System;
 
-namespace uPLibrary.Networking.M2Mqtt.Exceptions
+namespace uPLibrary.Networking.M2Mqtt.Exceptions {
-{
+  /// <summary>
-    /// <summary>
+  /// Timeout on receiving from broker exception
-    /// Timeout on receiving from broker exception
+  /// </summary>
-    /// </summary>
+  public class MqttTimeoutException : Exception {
-    public class MqttTimeoutException : Exception
+  }
-    {
-    }
 }

M2Mqtt/IMqttNetworkChannel.cs

@@ -15,55 +15,52 @@ Contributors:
 */
 
 using System;
-using System.Text;
 
-namespace uPLibrary.Networking.M2Mqtt
+namespace uPLibrary.Networking.M2Mqtt {
-{
+  /// <summary>
+  /// Interface for channel under MQTT library
+  /// </summary>
+  public interface IMqttNetworkChannel {
     /// <summary>
-    /// Interface for channel under MQTT library
+    /// Data available on channel
     /// </summary>
-    public interface IMqttNetworkChannel
+    Boolean DataAvailable { get; }
-    {
-        /// <summary>
-        /// Data available on channel
-        /// </summary>
-        bool DataAvailable { get; }
 
-        /// <summary>
+    /// <summary>
-        /// Receive data from the network channel
+    /// Receive data from the network channel
-        /// </summary>
+    /// </summary>
-        /// <param name="buffer">Data buffer for receiving data</param>
+    /// <param name="buffer">Data buffer for receiving data</param>
-        /// <returns>Number of bytes received</returns>
+    /// <returns>Number of bytes received</returns>
-        int Receive(byte[] buffer);
+    Int32 Receive(Byte[] buffer);
 
-        /// <summary>
+    /// <summary>
-        /// Receive data from the network channel with a specified timeout
+    /// Receive data from the network channel with a specified timeout
-        /// </summary>
+    /// </summary>
-        /// <param name="buffer">Data buffer for receiving data</param>
+    /// <param name="buffer">Data buffer for receiving data</param>
-        /// <param name="timeout">Timeout on receiving (in milliseconds)</param>
+    /// <param name="timeout">Timeout on receiving (in milliseconds)</param>
-        /// <returns>Number of bytes received</returns>
+    /// <returns>Number of bytes received</returns>
-        int Receive(byte[] buffer, int timeout);
+    Int32 Receive(Byte[] buffer, Int32 timeout);
 
-        /// <summary>
+    /// <summary>
-        /// Send data on the network channel to the broker
+    /// Send data on the network channel to the broker
-        /// </summary>
+    /// </summary>
-        /// <param name="buffer">Data buffer to send</param>
+    /// <param name="buffer">Data buffer to send</param>
-        /// <returns>Number of byte sent</returns>
+    /// <returns>Number of byte sent</returns>
-        int Send(byte[] buffer);
+    Int32 Send(Byte[] buffer);
 
-        /// <summary>
+    /// <summary>
-        /// Close the network channel
+    /// Close the network channel
-        /// </summary>
+    /// </summary>
-        void Close();
+    void Close();
 
-        /// <summary>
+    /// <summary>
-        /// Connect to remote server
+    /// Connect to remote server
-        /// </summary>
+    /// </summary>
-        void Connect();
+    void Connect();
 
-        /// <summary>
+    /// <summary>
-        /// Accept client connection
+    /// Accept client connection
-        /// </summary>
+    /// </summary>
-        void Accept();
+    void Accept();
-    }
+  }
 }

M2Mqtt/Internal/InternalEvent.cs

@@ -14,12 +14,10 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-namespace uPLibrary.Networking.M2Mqtt.Internal
+namespace uPLibrary.Networking.M2Mqtt.Internal {
-{
+  /// <summary>
-    /// <summary>
+  /// Generic internal event for dispatching
-    /// Generic internal event for dispatching
+  /// </summary>
-    /// </summary>
+  public abstract class InternalEvent {
-    public abstract class InternalEvent
+  }
-    {
-    }
 }

M2Mqtt/Internal/MsgInternalEvent.cs

@@ -16,36 +16,26 @@ Contributors:
 
 using uPLibrary.Networking.M2Mqtt.Messages;
 
-namespace uPLibrary.Networking.M2Mqtt.Internal
+namespace uPLibrary.Networking.M2Mqtt.Internal {
-{
+  /// <summary>
+  /// Internal event with a message
+  /// </summary>
+  public class MsgInternalEvent : InternalEvent {
+    #region Properties ...
+
     /// <summary>
-    /// Internal event with a message
+    /// Related message
     /// </summary>
-    public class MsgInternalEvent : InternalEvent
+    public MqttMsgBase Message { get; set; }
-    {
-        #region Properties ...
 
-        /// <summary>
+    #endregion
-        /// Related message
-        /// </summary>
-        public MqttMsgBase Message
-        {
-            get { return this.msg; }
-            set { this.msg = value; }
-        }
 
-        #endregion
+    // related message
 
-        // related message
+    /// <summary>
-        protected MqttMsgBase msg;
+    /// Constructor
-
+    /// </summary>
-        /// <summary>
+    /// <param name="msg">Related message</param>
-        /// Constructor
+    public MsgInternalEvent(MqttMsgBase msg) => this.Message = msg;
-        /// </summary>
+  }
-        /// <param name="msg">Related message</param>
-        public MsgInternalEvent(MqttMsgBase msg)
-        {
-            this.msg = msg;
-        }
-    }
 }

M2Mqtt/Internal/MsgPublishedInternalEvent.cs

@@ -14,40 +14,31 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using uPLibrary.Networking.M2Mqtt.Messages;
 
-namespace uPLibrary.Networking.M2Mqtt.Internal
+namespace uPLibrary.Networking.M2Mqtt.Internal {
-{
+  /// <summary>
+  /// Internal event for a published message
+  /// </summary>
+  public class MsgPublishedInternalEvent : MsgInternalEvent {
+    #region Properties...
+
     /// <summary>
-    /// Internal event for a published message
+    /// Message published (or failed due to retries)
     /// </summary>
-    public class MsgPublishedInternalEvent : MsgInternalEvent
+    public Boolean IsPublished { get; internal set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    #endregion
-        /// Message published (or failed due to retries)
-        /// </summary>
-        public bool IsPublished
-        {
-            get { return this.isPublished; }
-            internal set { this.isPublished = value; }
-        }
 
-        #endregion
+    // published flag
 
-        // published flag
+    /// <summary>
-        bool isPublished;
+    /// Constructor
-
+    /// </summary>
-        /// <summary>
+    /// <param name="msg">Message published</param>
-        /// Constructor
+    /// <param name="isPublished">Publish flag</param>
-        /// </summary>
+    public MsgPublishedInternalEvent(MqttMsgBase msg, Boolean isPublished)
-        /// <param name="msg">Message published</param>
+        : base(msg) => this.IsPublished = isPublished;
-        /// <param name="isPublished">Publish flag</param>
+  }
-        public MsgPublishedInternalEvent(MqttMsgBase msg, bool isPublished) 
-            : base(msg)
-        {
-            this.isPublished = isPublished;
-        }
-    }
 }

M2Mqtt/M2Mqtt.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <AssemblyName>M2Mqtt</AssemblyName>
+    <RootNamespace>uPLibrary.Networking.M2Mqtt</RootNamespace>
+    <Description>MQTT Client Library for M2M communication</Description>
+    <Authors>Paolo Patierno</Authors>
+    <Company>Paolo Patierno</Company>
+    <Copyright>Copyright © Paolo Patierno 2014</Copyright>
+    <Version>4.3.0</Version>
+    <AssemblyVersion>4.3.0</AssemblyVersion>
+    <FileVersion>4.3.0</FileVersion>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DefineConstants>TRACE;SSL</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DefineConstants>TRACE;SSL</DefineConstants>
+  </PropertyGroup>
+
+</Project>

M2Mqtt/Messages/MqttMsgBase.cs

@@ -17,259 +17,220 @@ Contributors:
 using System;
 using System.Text;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Base class for all MQTT messages
+  /// </summary>
+  public abstract class MqttMsgBase {
+    #region Constants...
+
+    // mask, offset and size for fixed header fields
+    internal const Byte MSG_TYPE_MASK = 0xF0;
+    internal const Byte MSG_TYPE_OFFSET = 0x04;
+    internal const Byte MSG_TYPE_SIZE = 0x04;
+    internal const Byte MSG_FLAG_BITS_MASK = 0x0F;      // [v3.1.1]
+    internal const Byte MSG_FLAG_BITS_OFFSET = 0x00;    // [v3.1.1]
+    internal const Byte MSG_FLAG_BITS_SIZE = 0x04;      // [v3.1.1]
+    internal const Byte DUP_FLAG_MASK = 0x08;
+    internal const Byte DUP_FLAG_OFFSET = 0x03;
+    internal const Byte DUP_FLAG_SIZE = 0x01;
+    internal const Byte QOS_LEVEL_MASK = 0x06;
+    internal const Byte QOS_LEVEL_OFFSET = 0x01;
+    internal const Byte QOS_LEVEL_SIZE = 0x02;
+    internal const Byte RETAIN_FLAG_MASK = 0x01;
+    internal const Byte RETAIN_FLAG_OFFSET = 0x00;
+    internal const Byte RETAIN_FLAG_SIZE = 0x01;
+
+    // MQTT message types
+    internal const Byte MQTT_MSG_CONNECT_TYPE = 0x01;
+    internal const Byte MQTT_MSG_CONNACK_TYPE = 0x02;
+    internal const Byte MQTT_MSG_PUBLISH_TYPE = 0x03;
+    internal const Byte MQTT_MSG_PUBACK_TYPE = 0x04;
+    internal const Byte MQTT_MSG_PUBREC_TYPE = 0x05;
+    internal const Byte MQTT_MSG_PUBREL_TYPE = 0x06;
+    internal const Byte MQTT_MSG_PUBCOMP_TYPE = 0x07;
+    internal const Byte MQTT_MSG_SUBSCRIBE_TYPE = 0x08;
+    internal const Byte MQTT_MSG_SUBACK_TYPE = 0x09;
+    internal const Byte MQTT_MSG_UNSUBSCRIBE_TYPE = 0x0A;
+    internal const Byte MQTT_MSG_UNSUBACK_TYPE = 0x0B;
+    internal const Byte MQTT_MSG_PINGREQ_TYPE = 0x0C;
+    internal const Byte MQTT_MSG_PINGRESP_TYPE = 0x0D;
+    internal const Byte MQTT_MSG_DISCONNECT_TYPE = 0x0E;
+
+    // [v3.1.1] MQTT flag bits
+    internal const Byte MQTT_MSG_CONNECT_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_CONNACK_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_PUBLISH_FLAG_BITS = 0x00; // just defined as 0x00 but depends on publish props (dup, qos, retain) 
+    internal const Byte MQTT_MSG_PUBACK_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_PUBREC_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_PUBREL_FLAG_BITS = 0x02;
+    internal const Byte MQTT_MSG_PUBCOMP_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_SUBSCRIBE_FLAG_BITS = 0x02;
+    internal const Byte MQTT_MSG_SUBACK_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_UNSUBSCRIBE_FLAG_BITS = 0x02;
+    internal const Byte MQTT_MSG_UNSUBACK_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_PINGREQ_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_PINGRESP_FLAG_BITS = 0x00;
+    internal const Byte MQTT_MSG_DISCONNECT_FLAG_BITS = 0x00;
+
+    // QOS levels
+    public const Byte QOS_LEVEL_AT_MOST_ONCE = 0x00;
+    public const Byte QOS_LEVEL_AT_LEAST_ONCE = 0x01;
+    public const Byte QOS_LEVEL_EXACTLY_ONCE = 0x02;
+
+    // SUBSCRIBE QoS level granted failure [v3.1.1]
+    public const Byte QOS_LEVEL_GRANTED_FAILURE = 0x80;
+
+    internal const UInt16 MAX_TOPIC_LENGTH = 65535;
+    internal const UInt16 MIN_TOPIC_LENGTH = 1;
+    internal const Byte MESSAGE_ID_SIZE = 2;
+
+    #endregion
+
+    #region Properties...
+
     /// <summary>
-    /// Base class for all MQTT messages
+    /// Message type
     /// </summary>
-    public abstract class MqttMsgBase
+    public Byte Type { get; set; }
-    {
-        #region Constants...
 
-        // mask, offset and size for fixed header fields
+    /// <summary>
-        internal const byte MSG_TYPE_MASK = 0xF0;
+    /// Duplicate message flag
-        internal const byte MSG_TYPE_OFFSET = 0x04;
+    /// </summary>
-        internal const byte MSG_TYPE_SIZE = 0x04;
+    public Boolean DupFlag { get; set; }
-        internal const byte MSG_FLAG_BITS_MASK = 0x0F;      // [v3.1.1]
-        internal const byte MSG_FLAG_BITS_OFFSET = 0x00;    // [v3.1.1]
-        internal const byte MSG_FLAG_BITS_SIZE = 0x04;      // [v3.1.1]
-        internal const byte DUP_FLAG_MASK = 0x08;
-        internal const byte DUP_FLAG_OFFSET = 0x03;
-        internal const byte DUP_FLAG_SIZE = 0x01;
-        internal const byte QOS_LEVEL_MASK = 0x06;
-        internal const byte QOS_LEVEL_OFFSET = 0x01;
-        internal const byte QOS_LEVEL_SIZE = 0x02;
-        internal const byte RETAIN_FLAG_MASK = 0x01;
-        internal const byte RETAIN_FLAG_OFFSET = 0x00;
-        internal const byte RETAIN_FLAG_SIZE = 0x01;
 
-        // MQTT message types
+    /// <summary>
-        internal const byte MQTT_MSG_CONNECT_TYPE = 0x01;
+    /// Quality of Service level
-        internal const byte MQTT_MSG_CONNACK_TYPE = 0x02;
+    /// </summary>
-        internal const byte MQTT_MSG_PUBLISH_TYPE = 0x03;
+    public Byte QosLevel { get; set; }
-        internal const byte MQTT_MSG_PUBACK_TYPE = 0x04;
-        internal const byte MQTT_MSG_PUBREC_TYPE = 0x05;
-        internal const byte MQTT_MSG_PUBREL_TYPE = 0x06;
-        internal const byte MQTT_MSG_PUBCOMP_TYPE = 0x07;
-        internal const byte MQTT_MSG_SUBSCRIBE_TYPE = 0x08;
-        internal const byte MQTT_MSG_SUBACK_TYPE = 0x09;
-        internal const byte MQTT_MSG_UNSUBSCRIBE_TYPE = 0x0A;
-        internal const byte MQTT_MSG_UNSUBACK_TYPE = 0x0B;
-        internal const byte MQTT_MSG_PINGREQ_TYPE = 0x0C;
-        internal const byte MQTT_MSG_PINGRESP_TYPE = 0x0D;
-        internal const byte MQTT_MSG_DISCONNECT_TYPE = 0x0E;
 
-        // [v3.1.1] MQTT flag bits
+    /// <summary>
-        internal const byte MQTT_MSG_CONNECT_FLAG_BITS = 0x00;
+    /// Retain message flag
-        internal const byte MQTT_MSG_CONNACK_FLAG_BITS = 0x00;
+    /// </summary>
-        internal const byte MQTT_MSG_PUBLISH_FLAG_BITS = 0x00; // just defined as 0x00 but depends on publish props (dup, qos, retain) 
+    public Boolean Retain { get; set; }
-        internal const byte MQTT_MSG_PUBACK_FLAG_BITS = 0x00;
-        internal const byte MQTT_MSG_PUBREC_FLAG_BITS = 0x00;
-        internal const byte MQTT_MSG_PUBREL_FLAG_BITS = 0x02;
-        internal const byte MQTT_MSG_PUBCOMP_FLAG_BITS = 0x00;
-        internal const byte MQTT_MSG_SUBSCRIBE_FLAG_BITS = 0x02;
-        internal const byte MQTT_MSG_SUBACK_FLAG_BITS = 0x00;
-        internal const byte MQTT_MSG_UNSUBSCRIBE_FLAG_BITS = 0x02;
-        internal const byte MQTT_MSG_UNSUBACK_FLAG_BITS = 0x00;
-        internal const byte MQTT_MSG_PINGREQ_FLAG_BITS = 0x00;
-        internal const byte MQTT_MSG_PINGRESP_FLAG_BITS = 0x00;
-        internal const byte MQTT_MSG_DISCONNECT_FLAG_BITS = 0x00;
 
-        // QOS levels
+    /// <summary>
-        public const byte QOS_LEVEL_AT_MOST_ONCE = 0x00;
+    /// Message identifier for the message
-        public const byte QOS_LEVEL_AT_LEAST_ONCE = 0x01;
+    /// </summary>
-        public const byte QOS_LEVEL_EXACTLY_ONCE = 0x02;
+    public UInt16 MessageId { get; set; }
 
-        // SUBSCRIBE QoS level granted failure [v3.1.1]
+    #endregion
-        public const byte QOS_LEVEL_GRANTED_FAILURE = 0x80;
 
-        internal const ushort MAX_TOPIC_LENGTH = 65535;
+    // message type
-        internal const ushort MIN_TOPIC_LENGTH = 1;
+    // duplicate delivery
-        internal const byte MESSAGE_ID_SIZE = 2;
+    // quality of service level
+    // retain flag
+    // message identifier
 
-        #endregion
+    /// <summary>
+    /// Returns message bytes rapresentation
+    /// </summary>
+    /// <param name="protocolVersion">Protocol version</param>
+    /// <returns>Bytes rapresentation</returns>
+    public abstract Byte[] GetBytes(Byte protocolVersion);
 
-        #region Properties...
+    /// <summary>
-
+    /// Encode remaining length and insert it into message buffer
-        /// <summary>
+    /// </summary>
-        /// Message type
+    /// <param name="remainingLength">Remaining length value to encode</param>
-        /// </summary>
+    /// <param name="buffer">Message buffer for inserting encoded value</param>
-        public byte Type
+    /// <param name="index">Index from which insert encoded value into buffer</param>
-        {
+    /// <returns>Index updated</returns>
-            get { return this.type; }
+    protected Int32 EncodeRemainingLength(Int32 remainingLength, Byte[] buffer, Int32 index) {
-            set { this.type = value; }
+      do {
+        Int32 digit = remainingLength % 128;
+        remainingLength /= 128;
+        if (remainingLength > 0) {
+          digit |= 0x80;
         }
 
-        /// <summary>
+        buffer[index++] = (Byte)digit;
-        /// Duplicate message flag
+      } while (remainingLength > 0);
-        /// </summary>
+      return index;
-        public bool DupFlag
+    }
-        {
-            get { return this.dupFlag; }
-            set { this.dupFlag = value; }
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Quality of Service level
+    /// Decode remaining length reading bytes from socket
-        /// </summary>
+    /// </summary>
-        public byte QosLevel
+    /// <param name="channel">Channel from reading bytes</param>
-        {
+    /// <returns>Decoded remaining length</returns>
-            get { return this.qosLevel; }
+    protected static Int32 DecodeRemainingLength(IMqttNetworkChannel channel) {
-            set { this.qosLevel = value; }
+      Int32 multiplier = 1;
-        }
+      Int32 value = 0;
-
+      Byte[] nextByte = new Byte[1];
-        /// <summary>
+      Int32 digit;
-        /// Retain message flag
+      do {
-        /// </summary>
+        // next digit from stream
-        public bool Retain
+        _ = channel.Receive(nextByte);
-        {
+        digit = nextByte[0];
-            get { return this.retain; }
+        value += (digit & 127) * multiplier;
-            set { this.retain = value; }
+        multiplier *= 128;
-        }
+      } while ((digit & 128) != 0);
-
+      return value;
-        /// <summary>
+    }
-        /// Message identifier for the message
-        /// </summary>
-        public ushort MessageId
-        {
-            get { return this.messageId; }
-            set { this.messageId = value; }
-        }
-
-        #endregion
-
-        // message type
-        protected byte type;
-        // duplicate delivery
-        protected bool dupFlag;
-        // quality of service level
-        protected byte qosLevel;
-        // retain flag
-        protected bool retain;
-        // message identifier
-        protected ushort messageId;
-
-        /// <summary>
-        /// Returns message bytes rapresentation
-        /// </summary>
-        /// <param name="protocolVersion">Protocol version</param>
-        /// <returns>Bytes rapresentation</returns>
-        public abstract byte[] GetBytes(byte protocolVersion);
-        
-        /// <summary>
-        /// Encode remaining length and insert it into message buffer
-        /// </summary>
-        /// <param name="remainingLength">Remaining length value to encode</param>
-        /// <param name="buffer">Message buffer for inserting encoded value</param>
-        /// <param name="index">Index from which insert encoded value into buffer</param>
-        /// <returns>Index updated</returns>
-        protected int encodeRemainingLength(int remainingLength, byte[] buffer, int index)
-        {
-            int digit = 0;
-            do
-            {
-                digit = remainingLength % 128;
-                remainingLength /= 128;
-                if (remainingLength > 0)
-                    digit = digit | 0x80;
-                buffer[index++] = (byte)digit;
-            } while (remainingLength > 0);
-            return index;
-        }
-
-        /// <summary>
-        /// Decode remaining length reading bytes from socket
-        /// </summary>
-        /// <param name="channel">Channel from reading bytes</param>
-        /// <returns>Decoded remaining length</returns>
-        protected static int decodeRemainingLength(IMqttNetworkChannel channel)
-        {
-            int multiplier = 1;
-            int value = 0;
-            int digit = 0;
-            byte[] nextByte = new byte[1];
-            do
-            {
-                // next digit from stream
-                channel.Receive(nextByte);
-                digit = nextByte[0];
-                value += ((digit & 127) * multiplier);
-                multiplier *= 128;
-            } while ((digit & 128) != 0);
-            return value;
-        }
 
 #if TRACE
-        /// <summary>
+    /// <summary>
-        /// Returns a string representation of the message for tracing
+    /// Returns a string representation of the message for tracing
-        /// </summary>
+    /// </summary>
-        /// <param name="name">Message name</param>
+    /// <param name="name">Message name</param>
-        /// <param name="fieldNames">Message fields name</param>
+    /// <param name="fieldNames">Message fields name</param>
-        /// <param name="fieldValues">Message fields value</param>
+    /// <param name="fieldValues">Message fields value</param>
-        /// <returns>String representation of the message</returns>
+    /// <returns>String representation of the message</returns>
-        protected string GetTraceString(string name, object[] fieldNames, object[] fieldValues)
+    protected String GetTraceString(String name, Object[] fieldNames, Object[] fieldValues) {
-        {
+      StringBuilder sb = new StringBuilder();
-            StringBuilder sb = new StringBuilder();
+      _ = sb.Append(name);
-            sb.Append(name);
 
-            if ((fieldNames != null) && (fieldValues != null))
+      if (fieldNames != null && fieldValues != null) {
-            {
+        _ = sb.Append("(");
-                sb.Append("(");
+        Boolean addComma = false;
-                bool addComma = false;
+        for (Int32 i = 0; i < fieldValues.Length; i++) {
-                for (int i = 0; i < fieldValues.Length; i++)
+          if (fieldValues[i] != null) {
-                {
+            if (addComma) {
-                    if (fieldValues[i] != null)
+              _ = sb.Append(",");
-                    {
-                        if (addComma)
-                        {
-                            sb.Append(",");
-                        }
-
-                        sb.Append(fieldNames[i]);
-                        sb.Append(":");
-                        sb.Append(GetStringObject(fieldValues[i]));
-                        addComma = true;
-                    }
-                }
-                sb.Append(")");
             }
 
-            return sb.ToString();
+            _ = sb.Append(fieldNames[i]);
+            _ = sb.Append(":");
+            _ = sb.Append(this.GetStringObject(fieldValues[i]));
+            addComma = true;
+          }
         }
+        _ = sb.Append(")");
+      }
 
-        object GetStringObject(object value)
+      return sb.ToString();
-        {
-            byte[] binary = value as byte[];
-            if (binary != null)
-            {
-                string hexChars = "0123456789ABCDEF";
-                StringBuilder sb = new StringBuilder(binary.Length * 2);
-                for (int i = 0; i < binary.Length; ++i)
-                {
-                    sb.Append(hexChars[binary[i] >> 4]);
-                    sb.Append(hexChars[binary[i] & 0x0F]);
-                }
-
-                return sb.ToString();
-            }
-
-            object[] list = value as object[];
-            if (list != null)
-            {
-                StringBuilder sb = new StringBuilder();
-                sb.Append('[');
-                for (int i = 0; i < list.Length; ++i)
-                {
-                    if (i > 0) sb.Append(',');
-                    sb.Append(list[i]);
-                }
-                sb.Append(']');
-
-                return sb.ToString();
-            }
-
-            return value;
-        }
-#endif
     }
+
+    Object GetStringObject(Object value) {
+      if (value is Byte[] binary) {
+        String hexChars = "0123456789ABCDEF";
+        StringBuilder sb = new StringBuilder(binary.Length * 2);
+        for (Int32 i = 0; i < binary.Length; ++i) {
+          _ = sb.Append(hexChars[binary[i] >> 4]);
+          _ = sb.Append(hexChars[binary[i] & 0x0F]);
+        }
+
+        return sb.ToString();
+      }
+
+      if (value is Object[] list) {
+        StringBuilder sb = new StringBuilder();
+        _ = sb.Append('[');
+        for (Int32 i = 0; i < list.Length; ++i) {
+          if (i > 0) {
+            _ = sb.Append(',');
+          }
+
+          _ = sb.Append(list[i]);
+        }
+        _ = sb.Append(']');
+
+        return sb.ToString();
+      }
+
+      return value;
+    }
+#endif
+  }
 }

M2Mqtt/Messages/MqttMsgConnack.cs

@@ -17,175 +17,153 @@ Contributors:
 using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for CONNACK message from broker to client
+  /// </summary>
+  public class MqttMsgConnack : MqttMsgBase {
+    #region Constants...
+
+    // return codes for CONNACK message
+    public const Byte CONN_ACCEPTED = 0x00;
+    public const Byte CONN_REFUSED_PROT_VERS = 0x01;
+    public const Byte CONN_REFUSED_IDENT_REJECTED = 0x02;
+    public const Byte CONN_REFUSED_SERVER_UNAVAILABLE = 0x03;
+    public const Byte CONN_REFUSED_USERNAME_PASSWORD = 0x04;
+    public const Byte CONN_REFUSED_NOT_AUTHORIZED = 0x05;
+
+    //private const Byte TOPIC_NAME_COMP_RESP_BYTE_OFFSET = 0;
+    private const Byte TOPIC_NAME_COMP_RESP_BYTE_SIZE = 1;
+    // [v3.1.1] connect acknowledge flags replace "old" topic name compression respone (not used in 3.1)
+    private const Byte CONN_ACK_FLAGS_BYTE_OFFSET = 0;
+    private const Byte CONN_ACK_FLAGS_BYTE_SIZE = 1;
+    // [v3.1.1] session present flag
+    private const Byte SESSION_PRESENT_FLAG_MASK = 0x01;
+    private const Byte SESSION_PRESENT_FLAG_OFFSET = 0x00;
+    //private const Byte SESSION_PRESENT_FLAG_SIZE = 0x01;
+    private const Byte CONN_RETURN_CODE_BYTE_OFFSET = 1;
+    private const Byte CONN_RETURN_CODE_BYTE_SIZE = 1;
+
+    #endregion
+
+    #region Properties...
+
+    // [v3.1.1] session present flag
     /// <summary>
-    /// Class for CONNACK message from broker to client
+    /// Session present flag
     /// </summary>
-    public class MqttMsgConnack : MqttMsgBase
+    public Boolean SessionPresent { get; set; }
-    {
-        #region Constants...
 
-        // return codes for CONNACK message
+    /// <summary>
-        public const byte CONN_ACCEPTED = 0x00;
+    /// Return Code
-        public const byte CONN_REFUSED_PROT_VERS = 0x01;
+    /// </summary>
-        public const byte CONN_REFUSED_IDENT_REJECTED = 0x02;
+    public Byte ReturnCode { get; set; }
-        public const byte CONN_REFUSED_SERVER_UNAVAILABLE = 0x03;
-        public const byte CONN_REFUSED_USERNAME_PASSWORD = 0x04;
-        public const byte CONN_REFUSED_NOT_AUTHORIZED = 0x05;
 
-        private const byte TOPIC_NAME_COMP_RESP_BYTE_OFFSET = 0;
+    #endregion
-        private const byte TOPIC_NAME_COMP_RESP_BYTE_SIZE = 1;
-        // [v3.1.1] connect acknowledge flags replace "old" topic name compression respone (not used in 3.1)
-        private const byte CONN_ACK_FLAGS_BYTE_OFFSET = 0;
-        private const byte CONN_ACK_FLAGS_BYTE_SIZE = 1;
-        // [v3.1.1] session present flag
-        private const byte SESSION_PRESENT_FLAG_MASK = 0x01;
-        private const byte SESSION_PRESENT_FLAG_OFFSET = 0x00;
-        private const byte SESSION_PRESENT_FLAG_SIZE = 0x01;
-        private const byte CONN_RETURN_CODE_BYTE_OFFSET = 1;
-        private const byte CONN_RETURN_CODE_BYTE_SIZE = 1;
 
-        #endregion
+    // [v3.1.1] session present flag
 
-        #region Properties...
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    public MqttMsgConnack() => this.Type = MQTT_MSG_CONNACK_TYPE;
 
-        // [v3.1.1] session present flag
+    /// <summary>
-        /// <summary>
+    /// Parse bytes for a CONNACK message
-        /// Session present flag
+    /// </summary>
-        /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        public bool SessionPresent
+    /// <param name="protocolVersion">Protocol Version</param>
-        {
+    /// <param name="channel">Channel connected to the broker</param>
-            get { return this.sessionPresent; }
+    /// <returns>CONNACK message instance</returns>
-            set { this.sessionPresent = value; }
+    public static MqttMsgConnack Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      MqttMsgConnack msg = new MqttMsgConnack();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_CONNACK_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
         }
+      }
 
-        /// <summary>
+      // get remaining length and allocate buffer
-        /// Return Code
+      Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
-        /// </summary>
+      buffer = new Byte[remainingLength];
-        public byte ReturnCode
-        {
-            get { return this.returnCode; }
-            set { this.returnCode = value; }
-        }
 
-        #endregion
+      // read bytes from socket...
+      _ = channel.Receive(buffer);
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] ... set session present flag ...
+        msg.SessionPresent = (buffer[CONN_ACK_FLAGS_BYTE_OFFSET] & SESSION_PRESENT_FLAG_MASK) != 0x00;
+      }
+      // ...and set return code from broker
+      msg.ReturnCode = buffer[CONN_RETURN_CODE_BYTE_OFFSET];
 
-        // [v3.1.1] session present flag
+      return msg;
-        private bool sessionPresent;
-
-        // return code for CONNACK message
-        private byte returnCode;
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public MqttMsgConnack()
-        {
-            this.type = MQTT_MSG_CONNACK_TYPE;
-        }
-
-        /// <summary>
-        /// Parse bytes for a CONNACK message
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>CONNACK message instance</returns>
-        public static MqttMsgConnack Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            MqttMsgConnack msg = new MqttMsgConnack();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_CONNACK_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            channel.Receive(buffer);
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] ... set session present flag ...
-                msg.sessionPresent = (buffer[CONN_ACK_FLAGS_BYTE_OFFSET] & SESSION_PRESENT_FLAG_MASK) != 0x00;
-            }
-            // ...and set return code from broker
-            msg.returnCode = buffer[CONN_RETURN_CODE_BYTE_OFFSET];
-
-            return msg;
-        }
-
-        public override byte[] GetBytes(byte ProtocolVersion)
-        {
-            int fixedHeaderSize = 0;
-            int varHeaderSize = 0;
-            int payloadSize = 0;
-            int remainingLength = 0;
-            byte[] buffer;
-            int index = 0;
-
-            if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                // flags byte and connect return code
-                varHeaderSize += (CONN_ACK_FLAGS_BYTE_SIZE + CONN_RETURN_CODE_BYTE_SIZE);
-            else
-                // topic name compression response and connect return code
-                varHeaderSize += (TOPIC_NAME_COMP_RESP_BYTE_SIZE + CONN_RETURN_CODE_BYTE_SIZE);
-
-            remainingLength += (varHeaderSize + payloadSize);
-
-            // first byte of fixed header
-            fixedHeaderSize = 1;
-
-            int temp = remainingLength;
-            // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
-            do
-            {
-                fixedHeaderSize++;
-                temp = temp / 128;
-            } while (temp > 0);
-
-            // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
-
-            // first fixed header byte
-            if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_CONNACK_FLAG_BITS; // [v.3.1.1]
-            else
-                buffer[index++] = (byte)(MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET);
-            
-            // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
-
-            if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                // [v3.1.1] session present flag
-                buffer[index++] = this.sessionPresent ? (byte)(1 << SESSION_PRESENT_FLAG_OFFSET) : (byte)0x00;
-            else
-                // topic name compression response (reserved values. not used);
-                buffer[index++] = 0x00;
-            
-            // connect return code
-            buffer[index++] = this.returnCode;
-
-            return buffer;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "CONNACK",
-                new object[] { "returnCode" },
-                new object[] { this.returnCode });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override Byte[] GetBytes(Byte ProtocolVersion) {
+      Int32 varHeaderSize = 0;
+      Int32 payloadSize = 0;
+      Int32 remainingLength = 0;
+      Byte[] buffer;
+      Int32 index = 0;
+
+      if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // flags byte and connect return code
+        varHeaderSize += CONN_ACK_FLAGS_BYTE_SIZE + CONN_RETURN_CODE_BYTE_SIZE;
+      } else {
+        // topic name compression response and connect return code
+        varHeaderSize += TOPIC_NAME_COMP_RESP_BYTE_SIZE + CONN_RETURN_CODE_BYTE_SIZE;
+      }
+
+      remainingLength += varHeaderSize + payloadSize;
+
+      // first byte of fixed header
+      Int32 fixedHeaderSize = 1;
+
+      Int32 temp = remainingLength;
+      // increase fixed header size based on remaining length
+      // (each remaining length byte can encode until 128)
+      do {
+        fixedHeaderSize++;
+        temp /= 128;
+      } while (temp > 0);
+
+      // allocate buffer for message
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+      // first fixed header byte
+      buffer[index++] = ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
+        ? (Byte)((MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_CONNACK_FLAG_BITS)
+        : (Byte)(MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET);
+
+      // encode remaining length
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
+
+      if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] session present flag
+        buffer[index++] = this.SessionPresent ? (Byte)(1 << SESSION_PRESENT_FLAG_OFFSET) : (Byte)0x00;
+      } else {
+        // topic name compression response (reserved values. not used);
+        buffer[index++] = 0x00;
+      }
+
+      // connect return code
+      buffer[index++] = this.ReturnCode;
+
+      return buffer;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "CONNACK",
+          new Object[] { "returnCode" },
+          new Object[] { this.ReturnCode });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgConnectEventArgs.cs

@@ -14,31 +14,26 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System;
 #else
 using Microsoft.SPOT;
 #endif
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Event Args class for CONNECT message received from client
+  /// </summary>
+  public class MqttMsgConnectEventArgs : EventArgs {
     /// <summary>
-    /// Event Args class for CONNECT message received from client
+    /// Message received from client
     /// </summary>
-    public class MqttMsgConnectEventArgs : EventArgs
+    public MqttMsgConnect Message { get; private set; }
-    {
-        /// <summary>
-        /// Message received from client
-        /// </summary>
-        public MqttMsgConnect Message { get; private set; }
 
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Constructor
-        /// </summary>
+    /// </summary>
-        /// <param name="msg">CONNECT message received from client</param>
+    /// <param name="msg">CONNECT message received from client</param>
-        public MqttMsgConnectEventArgs(MqttMsgConnect connect)
+    public MqttMsgConnectEventArgs(MqttMsgConnect connect) => this.Message = connect;
-        {
+  }
-            this.Message = connect;
-        }
-    }
 }

M2Mqtt/Messages/MqttMsgContext.cs

@@ -15,145 +15,137 @@ Contributors:
 */
 
 using System;
-using System.Text;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Context for MQTT message
+  /// </summary>
+  public class MqttMsgContext {
     /// <summary>
-    /// Context for MQTT message
+    /// MQTT message
     /// </summary>
-    public class MqttMsgContext
+    public MqttMsgBase Message { get; set; }
-    {
-        /// <summary>
-        /// MQTT message
-        /// </summary>
-        public MqttMsgBase Message { get; set; }
-
-        /// <summary>
-        /// MQTT message state
-        /// </summary>
-        public MqttMsgState State { get; set; }
-
-        /// <summary>
-        /// Flow of the message
-        /// </summary>
-        public MqttMsgFlow Flow { get; set; }
-
-        /// <summary>
-        /// Timestamp in ticks (for retry)
-        /// </summary>
-        public int Timestamp { get; set; }
-
-        /// <summary>
-        /// Attempt (for retry)
-        /// </summary>
-        public int Attempt { get; set; }
-
-        /// <summary>
-        /// Unique key
-        /// </summary>
-        public string Key 
-        {
-            get { return this.Flow + "_" + this.Message.MessageId; }
-        }
-    }
-
-    /// <summary>
-    /// Flow of the message
-    /// </summary>
-    public enum MqttMsgFlow
-    {
-        /// <summary>
-        /// To publish to subscribers
-        /// </summary>
-        ToPublish,
-
-        /// <summary>
-        /// To acknowledge to publisher
-        /// </summary>
-        ToAcknowledge
-    }
 
     /// <summary>
     /// MQTT message state
     /// </summary>
-    public enum MqttMsgState
+    public MqttMsgState State { get; set; }
-    {
-        /// <summary>
-        /// QOS = 0, Message queued
-        /// </summary>
-        QueuedQos0,
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 1, Message queued
+    /// Flow of the message
-        /// </summary>
+    /// </summary>
-        QueuedQos1,
+    public MqttMsgFlow Flow { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 2, Message queued
+    /// Timestamp in ticks (for retry)
-        /// </summary>
+    /// </summary>
-        QueuedQos2,
+    public Int32 Timestamp { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 1, PUBLISH sent, wait for PUBACK
+    /// Attempt (for retry)
-        /// </summary>
+    /// </summary>
-        WaitForPuback,
+    public Int32 Attempt { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 2, PUBLISH sent, wait for PUBREC
+    /// Unique key
-        /// </summary>
+    /// </summary>
-        WaitForPubrec,
+    public String Key => this.Flow + "_" + this.Message.MessageId;
+  }
 
-        /// <summary>
+  /// <summary>
-        /// QOS = 2, PUBREC sent, wait for PUBREL
+  /// Flow of the message
-        /// </summary>
+  /// </summary>
-        WaitForPubrel,
+  public enum MqttMsgFlow {
+    /// <summary>
+    /// To publish to subscribers
+    /// </summary>
+    ToPublish,
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 2, PUBREL sent, wait for PUBCOMP
+    /// To acknowledge to publisher
-        /// </summary>
+    /// </summary>
-        WaitForPubcomp,
+    ToAcknowledge
+  }
 
-        /// <summary>
+  /// <summary>
-        /// QOS = 2, start first phase handshake send PUBREC
+  /// MQTT message state
-        /// </summary>
+  /// </summary>
-        SendPubrec,
+  public enum MqttMsgState {
+    /// <summary>
+    /// QOS = 0, Message queued
+    /// </summary>
+    QueuedQos0,
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 2, start second phase handshake send PUBREL
+    /// QOS = 1, Message queued
-        /// </summary>
+    /// </summary>
-        SendPubrel,
+    QueuedQos1,
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 2, end second phase handshake send PUBCOMP
+    /// QOS = 2, Message queued
-        /// </summary>
+    /// </summary>
-        SendPubcomp,
+    QueuedQos2,
 
-        /// <summary>
+    /// <summary>
-        /// QOS = 1, PUBLISH received, send PUBACK
+    /// QOS = 1, PUBLISH sent, wait for PUBACK
-        /// </summary>
+    /// </summary>
-        SendPuback,
+    WaitForPuback,
 
-        // [v3.1.1] SUBSCRIBE isn't "officially" QOS = 1
+    /// <summary>
-        /// <summary>
+    /// QOS = 2, PUBLISH sent, wait for PUBREC
-        /// Send SUBSCRIBE message
+    /// </summary>
-        /// </summary>
+    WaitForPubrec,
-        SendSubscribe,
 
-        // [v3.1.1] UNSUBSCRIBE isn't "officially" QOS = 1
+    /// <summary>
-        /// <summary>
+    /// QOS = 2, PUBREC sent, wait for PUBREL
-        /// Send UNSUBSCRIBE message
+    /// </summary>
-        /// </summary>
+    WaitForPubrel,
-        SendUnsubscribe,
 
-        /// <summary>
+    /// <summary>
-        /// (QOS = 1), SUBSCRIBE sent, wait for SUBACK
+    /// QOS = 2, PUBREL sent, wait for PUBCOMP
-        /// </summary>
+    /// </summary>
-        WaitForSuback,
+    WaitForPubcomp,
 
-        /// <summary>
+    /// <summary>
-        /// (QOS = 1), UNSUBSCRIBE sent, wait for UNSUBACK
+    /// QOS = 2, start first phase handshake send PUBREC
-        /// </summary>
+    /// </summary>
-        WaitForUnsuback
+    SendPubrec,
-    }
+
+    /// <summary>
+    /// QOS = 2, start second phase handshake send PUBREL
+    /// </summary>
+    SendPubrel,
+
+    /// <summary>
+    /// QOS = 2, end second phase handshake send PUBCOMP
+    /// </summary>
+    SendPubcomp,
+
+    /// <summary>
+    /// QOS = 1, PUBLISH received, send PUBACK
+    /// </summary>
+    SendPuback,
+
+    // [v3.1.1] SUBSCRIBE isn't "officially" QOS = 1
+    /// <summary>
+    /// Send SUBSCRIBE message
+    /// </summary>
+    SendSubscribe,
+
+    // [v3.1.1] UNSUBSCRIBE isn't "officially" QOS = 1
+    /// <summary>
+    /// Send UNSUBSCRIBE message
+    /// </summary>
+    SendUnsubscribe,
+
+    /// <summary>
+    /// (QOS = 1), SUBSCRIBE sent, wait for SUBACK
+    /// </summary>
+    WaitForSuback,
+
+    /// <summary>
+    /// (QOS = 1), UNSUBSCRIBE sent, wait for UNSUBACK
+    /// </summary>
+    WaitForUnsuback
+  }
 }

M2Mqtt/Messages/MqttMsgDisconnect.cs

@@ -14,73 +14,66 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for DISCONNECT message from client to broker
+  /// </summary>
+  public class MqttMsgDisconnect : MqttMsgBase {
     /// <summary>
-    /// Class for DISCONNECT message from client to broker
+    /// Constructor
     /// </summary>
-    public class MqttMsgDisconnect : MqttMsgBase
+    public MqttMsgDisconnect() => this.Type = MQTT_MSG_DISCONNECT_TYPE;
-    {
+
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Parse bytes for a DISCONNECT message
-        /// </summary>
+    /// </summary>
-        public MqttMsgDisconnect()
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        {
+    /// <param name="protocolVersion">Protocol Version</param>
-            this.type = MQTT_MSG_DISCONNECT_TYPE;
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>DISCONNECT message instance</returns>
+    public static MqttMsgDisconnect Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      MqttMsgDisconnect msg = new MqttMsgDisconnect();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_DISCONNECT_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
         }
+      }
 
-        /// <summary>
+      // get remaining length and allocate buffer
-        /// Parse bytes for a DISCONNECT message
+      _ = DecodeRemainingLength(channel);
-        /// </summary>
+      // NOTE : remainingLength must be 0
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>DISCONNECT message instance</returns>
-        public static MqttMsgDisconnect Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            MqttMsgDisconnect msg = new MqttMsgDisconnect();
 
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      return msg;
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_DISCONNECT_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            // NOTE : remainingLength must be 0
-
-            return msg;
-        }
-
-        public override byte[] GetBytes(byte protocolVersion)
-        {
-            byte[] buffer = new byte[2];
-            int index = 0;
-
-            // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_DISCONNECT_FLAG_BITS; // [v.3.1.1]
-            else
-                buffer[index++] = (MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET);
-            buffer[index++] = 0x00;
-
-            return buffer;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "DISCONNECT",
-                null,
-                null);
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override Byte[] GetBytes(Byte protocolVersion) {
+      Byte[] buffer = new Byte[2];
+      Int32 index = 0;
+
+      // first fixed header byte
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
+        ? (Byte)((MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_DISCONNECT_FLAG_BITS)
+        : (Byte)(MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET);
+
+      buffer[index++] = 0x00;
+
+      return buffer;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "DISCONNECT",
+          null,
+          null);
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgPingReq.cs

@@ -14,73 +14,66 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for PINGREQ message from client to broker
+  /// </summary>
+  public class MqttMsgPingReq : MqttMsgBase {
     /// <summary>
-    /// Class for PINGREQ message from client to broker
+    /// Constructor
     /// </summary>
-    public class MqttMsgPingReq : MqttMsgBase
+    public MqttMsgPingReq() => this.Type = MQTT_MSG_PINGREQ_TYPE;
-    {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public MqttMsgPingReq()
-        {
-            this.type = MQTT_MSG_PINGREQ_TYPE;
-        }
 
-        public override byte[] GetBytes(byte protocolVersion)
+    public override Byte[] GetBytes(Byte protocolVersion) {
-        {
+      Byte[] buffer = new Byte[2];
-            byte[] buffer = new byte[2];
+      Int32 index = 0;
-            int index = 0;
 
-            // first fixed header byte
+      // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
-                buffer[index++] = (MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGREQ_FLAG_BITS; // [v.3.1.1]
+        ? (Byte)((MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGREQ_FLAG_BITS)
-            else
+        : (Byte)(MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET);
-                buffer[index++] = (MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET);
-            buffer[index++] = 0x00;
 
-            return buffer;
+      buffer[index++] = 0x00;
-        }
 
-        /// <summary>
+      return buffer;
-        /// Parse bytes for a PINGREQ message
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>PINGREQ message instance</returns>
-        public static MqttMsgPingReq Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            MqttMsgPingReq msg = new MqttMsgPingReq();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGREQ_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // already know remaininglength is zero (MQTT specification),
-            // so it isn't necessary to read other data from socket
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-
-            return msg;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "PINGREQ",
-                null,
-                null);
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    /// <summary>
+    /// Parse bytes for a PINGREQ message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>PINGREQ message instance</returns>
+    public static MqttMsgPingReq Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      MqttMsgPingReq msg = new MqttMsgPingReq();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGREQ_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
+        }
+      }
+
+      // already know remaininglength is zero (MQTT specification),
+      // so it isn't necessary to read other data from socket
+      _ = DecodeRemainingLength(channel);
+
+      return msg;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "PINGREQ",
+          null,
+          null);
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgPingResp.cs

@@ -17,71 +17,63 @@ Contributors:
 using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for PINGRESP message from client to broker
+  /// </summary>
+  public class MqttMsgPingResp : MqttMsgBase {
     /// <summary>
-    /// Class for PINGRESP message from client to broker
+    /// Constructor
     /// </summary>
-    public class MqttMsgPingResp : MqttMsgBase
+    public MqttMsgPingResp() => this.Type = MQTT_MSG_PINGRESP_TYPE;
-    {
+
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Parse bytes for a PINGRESP message
-        /// </summary>
+    /// </summary>
-        public MqttMsgPingResp()
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        {
+    /// <param name="protocolVersion">Protocol Version</param>
-            this.type = MQTT_MSG_PINGRESP_TYPE;
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>PINGRESP message instance</returns>
+    public static MqttMsgPingResp Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      MqttMsgPingResp msg = new MqttMsgPingResp();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGRESP_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
         }
+      }
 
-        /// <summary>
+      // already know remaininglength is zero (MQTT specification),
-        /// Parse bytes for a PINGRESP message
+      // so it isn't necessary to read other data from socket
-        /// </summary>
+      _ = DecodeRemainingLength(channel);
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>PINGRESP message instance</returns>
-        public static MqttMsgPingResp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            MqttMsgPingResp msg = new MqttMsgPingResp();
 
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      return msg;
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGRESP_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // already know remaininglength is zero (MQTT specification),
-            // so it isn't necessary to read other data from socket
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            
-            return msg;
-        }
-
-        public override byte[] GetBytes(byte protocolVersion)
-        {
-            byte[] buffer = new byte[2];
-            int index = 0;
-
-            // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGRESP_FLAG_BITS; // [v.3.1.1]
-            else
-                buffer[index++] = (MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET);
-            buffer[index++] = 0x00;
-
-            return buffer;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "PINGRESP",
-                null,
-                null);
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override Byte[] GetBytes(Byte protocolVersion) {
+      Byte[] buffer = new Byte[2];
+      Int32 index = 0;
+
+      // first fixed header byte
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
+        ? (Byte)((MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGRESP_FLAG_BITS)
+        : (Byte)(MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET);
+
+      buffer[index++] = 0x00;
+
+      return buffer;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "PINGRESP",
+          null,
+          null);
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgPuback.cs

@@ -14,112 +14,102 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for PUBACK message from broker to client
+  /// </summary>
+  public class MqttMsgPuback : MqttMsgBase {
     /// <summary>
-    /// Class for PUBACK message from broker to client
+    /// Constructor
     /// </summary>
-    public class MqttMsgPuback : MqttMsgBase
+    public MqttMsgPuback() => this.Type = MQTT_MSG_PUBACK_TYPE;
-    {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public MqttMsgPuback()
-        {
-            this.type = MQTT_MSG_PUBACK_TYPE;
-        }
 
-        public override byte[] GetBytes(byte protocolVersion)
+    public override Byte[] GetBytes(Byte protocolVersion) {
-        {
+      Int32 varHeaderSize = 0;
-            int fixedHeaderSize = 0;
+      Int32 payloadSize = 0;
-            int varHeaderSize = 0;
+      Int32 remainingLength = 0;
-            int payloadSize = 0;
+      Byte[] buffer;
-            int remainingLength = 0;
+      Int32 index = 0;
-            byte[] buffer;
-            int index = 0;
 
-            // message identifier
+      // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
+      varHeaderSize += MESSAGE_ID_SIZE;
 
-            remainingLength += (varHeaderSize + payloadSize);
+      remainingLength += varHeaderSize + payloadSize;
 
-            // first byte of fixed header
+      // first byte of fixed header
-            fixedHeaderSize = 1;
+      Int32 fixedHeaderSize = 1;
 
-            int temp = remainingLength;
+      Int32 temp = remainingLength;
-            // increase fixed header size based on remaining length
+      // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
+      // (each remaining length byte can encode until 128)
-            do
+      do {
-            {
+        fixedHeaderSize++;
-                fixedHeaderSize++;
+        temp /= 128;
-                temp = temp / 128;
+      } while (temp > 0);
-            } while (temp > 0);
 
-            // allocate buffer for message
+      // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
 
-            // first fixed header byte
+      // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
-                buffer[index++] = (MQTT_MSG_PUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBACK_FLAG_BITS; // [v.3.1.1]
+        ? (Byte)((MQTT_MSG_PUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBACK_FLAG_BITS)
-            else
+        : (Byte)(MQTT_MSG_PUBACK_TYPE << MSG_TYPE_OFFSET);
-                buffer[index++] = (MQTT_MSG_PUBACK_TYPE << MSG_TYPE_OFFSET);
 
-            // encode remaining length
+      // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
 
-            // get message identifier
+      // get message identifier
-            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
+      buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB 
 
-            return buffer;
+      return buffer;
-        }
-
-        /// <summary>
-        /// Parse bytes for a PUBACK message
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>PUBACK message instance</returns>
-        public static MqttMsgPuback Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            MqttMsgPuback msg = new MqttMsgPuback();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBACK_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            channel.Receive(buffer);
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            return msg;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "PUBACK",
-                new object[] { "messageId" },
-                new object[] { this.messageId });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    /// <summary>
+    /// Parse bytes for a PUBACK message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>PUBACK message instance</returns>
+    public static MqttMsgPuback Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      Int32 index = 0;
+      MqttMsgPuback msg = new MqttMsgPuback();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBACK_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
+        }
+      }
+
+      // get remaining length and allocate buffer
+      Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
+      buffer = new Byte[remainingLength];
+
+      // read bytes from socket...
+      _ = channel.Receive(buffer);
+
+      // message id
+      msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
+      msg.MessageId |= buffer[index++];
+
+      return msg;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "PUBACK",
+          new Object[] { "messageId" },
+          new Object[] { this.MessageId });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgPubcomp.cs

@@ -14,112 +14,102 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for PUBCOMP message from broker to client
+  /// </summary>
+  public class MqttMsgPubcomp : MqttMsgBase {
     /// <summary>
-    /// Class for PUBCOMP message from broker to client
+    /// Constructor
     /// </summary>
-    public class MqttMsgPubcomp : MqttMsgBase
+    public MqttMsgPubcomp() => this.Type = MQTT_MSG_PUBCOMP_TYPE;
-    {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public MqttMsgPubcomp()
-        {
-            this.type = MQTT_MSG_PUBCOMP_TYPE;
-        }
 
-        public override byte[] GetBytes(byte protocolVersion)
+    public override Byte[] GetBytes(Byte protocolVersion) {
-        {
+      Int32 varHeaderSize = 0;
-            int fixedHeaderSize = 0;
+      Int32 payloadSize = 0;
-            int varHeaderSize = 0;
+      Int32 remainingLength = 0;
-            int payloadSize = 0;
+      Byte[] buffer;
-            int remainingLength = 0;
+      Int32 index = 0;
-            byte[] buffer;
-            int index = 0;
 
-            // message identifier
+      // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
+      varHeaderSize += MESSAGE_ID_SIZE;
 
-            remainingLength += (varHeaderSize + payloadSize);
+      remainingLength += varHeaderSize + payloadSize;
 
-            // first byte of fixed header
+      // first byte of fixed header
-            fixedHeaderSize = 1;
+      Int32 fixedHeaderSize = 1;
 
-            int temp = remainingLength;
+      Int32 temp = remainingLength;
-            // increase fixed header size based on remaining length
+      // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
+      // (each remaining length byte can encode until 128)
-            do
+      do {
-            {
+        fixedHeaderSize++;
-                fixedHeaderSize++;
+        temp /= 128;
-                temp = temp / 128;
+      } while (temp > 0);
-            } while (temp > 0);
 
-            // allocate buffer for message
+      // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
 
-            // first fixed header byte
+      // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
-                buffer[index++] = (MQTT_MSG_PUBCOMP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBCOMP_FLAG_BITS; // [v.3.1.1]
+        ? (Byte)((MQTT_MSG_PUBCOMP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBCOMP_FLAG_BITS)
-            else
+        : (Byte)(MQTT_MSG_PUBCOMP_TYPE << MSG_TYPE_OFFSET);
-                buffer[index++] = (MQTT_MSG_PUBCOMP_TYPE << MSG_TYPE_OFFSET);
 
-            // encode remaining length
+      // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
 
-            // get message identifier
+      // get message identifier
-            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
+      buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB 
 
-            return buffer;
+      return buffer;
-        }
-
-        /// <summary>
-        /// Parse bytes for a PUBCOMP message
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>PUBCOMP message instance</returns>
-        public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            MqttMsgPubcomp msg = new MqttMsgPubcomp();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            channel.Receive(buffer);
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            return msg;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "PUBCOMP",
-                new object[] { "messageId" },
-                new object[] { this.messageId });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    /// <summary>
+    /// Parse bytes for a PUBCOMP message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>PUBCOMP message instance</returns>
+    public static MqttMsgPubcomp Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      Int32 index = 0;
+      MqttMsgPubcomp msg = new MqttMsgPubcomp();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
+        }
+      }
+
+      // get remaining length and allocate buffer
+      Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
+      buffer = new Byte[remainingLength];
+
+      // read bytes from socket...
+      _ = channel.Receive(buffer);
+
+      // message id
+      msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
+      msg.MessageId |= buffer[index++];
+
+      return msg;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "PUBCOMP",
+          new Object[] { "messageId" },
+          new Object[] { this.MessageId });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgPublish.cs

@@ -40,9 +40,7 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
     /// <summary>
     /// Constructor
     /// </summary>
-    public MqttMsgPublish() {
+    public MqttMsgPublish() => this.Type = MQTT_MSG_PUBLISH_TYPE;
-      this.type = MQTT_MSG_PUBLISH_TYPE;
-    }
 
     /// <summary>
     /// Constructor
@@ -61,17 +59,16 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
     /// <param name="qosLevel">Quality of Service level</param>
     /// <param name="retain">Retain flag</param>
     public MqttMsgPublish(String topic, Byte[] message, Boolean dupFlag, Byte qosLevel, Boolean retain) : base() {
-      this.type = MQTT_MSG_PUBLISH_TYPE;
+      this.Type = MQTT_MSG_PUBLISH_TYPE;
       this.Topic = topic;
       this.Message = message;
-      this.dupFlag = dupFlag;
+      this.DupFlag = dupFlag;
-      this.qosLevel = qosLevel;
+      this.QosLevel = qosLevel;
-      this.retain = retain;
+      this.Retain = retain;
-      this.messageId = 0;
+      this.MessageId = 0;
     }
 
     public override Byte[] GetBytes(Byte protocolVersion) {
-      Int32 fixedHeaderSize = 0;
       Int32 varHeaderSize = 0;
       Int32 payloadSize = 0;
       Int32 remainingLength = 0;
@@ -79,17 +76,17 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
       Int32 index = 0;
 
       // topic can't contain wildcards
-      if ((this.Topic.IndexOf('#') != -1) || (this.Topic.IndexOf('+') != -1)) {
+      if (this.Topic.IndexOf('#') != -1 || this.Topic.IndexOf('+') != -1) {
         throw new MqttClientException(MqttClientErrorCode.TopicWildcard);
       }
 
       // check topic length
-      if ((this.Topic.Length < MIN_TOPIC_LENGTH) || (this.Topic.Length > MAX_TOPIC_LENGTH)) {
+      if (this.Topic.Length < MIN_TOPIC_LENGTH || this.Topic.Length > MAX_TOPIC_LENGTH) {
         throw new MqttClientException(MqttClientErrorCode.TopicLength);
       }
 
       // check wrong QoS level (both bits can't be set 1)
-      if (this.qosLevel > QOS_LEVEL_EXACTLY_ONCE) {
+      if (this.QosLevel > QOS_LEVEL_EXACTLY_ONCE) {
         throw new MqttClientException(MqttClientErrorCode.QosNotAllowed);
       }
 
@@ -99,7 +96,7 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
       varHeaderSize += topicUtf8.Length + 2;
 
       // message id is valid only with QOS level 1 or QOS level 2
-      if ((this.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) || (this.qosLevel == QOS_LEVEL_EXACTLY_ONCE)) {
+      if (this.QosLevel == QOS_LEVEL_AT_LEAST_ONCE || this.QosLevel == QOS_LEVEL_EXACTLY_ONCE) {
         varHeaderSize += MESSAGE_ID_SIZE;
       }
 
@@ -109,30 +106,30 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
         payloadSize += this.Message.Length;
       }
 
-      remainingLength += (varHeaderSize + payloadSize);
+      remainingLength += varHeaderSize + payloadSize;
 
       // first byte of fixed header
-      fixedHeaderSize = 1;
+      Int32 fixedHeaderSize = 1;
 
       Int32 temp = remainingLength;
       // increase fixed header size based on remaining length
       // (each remaining length byte can encode until 128)
       do {
         fixedHeaderSize++;
-        temp = temp / 128;
+        temp /= 128;
       } while (temp > 0);
 
       // allocate buffer for message
       buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
 
       // first fixed header byte
-      buffer[index] = (Byte)((MQTT_MSG_PUBLISH_TYPE << MSG_TYPE_OFFSET) | (this.qosLevel << QOS_LEVEL_OFFSET));
+      buffer[index] = (Byte)((MQTT_MSG_PUBLISH_TYPE << MSG_TYPE_OFFSET) | (this.QosLevel << QOS_LEVEL_OFFSET));
-      buffer[index] |= this.dupFlag ? (Byte)(1 << DUP_FLAG_OFFSET) : (Byte)0x00;
+      buffer[index] |= this.DupFlag ? (Byte)(1 << DUP_FLAG_OFFSET) : (Byte)0x00;
-      buffer[index] |= this.retain ? (Byte)(1 << RETAIN_FLAG_OFFSET) : (Byte)0x00;
+      buffer[index] |= this.Retain ? (Byte)(1 << RETAIN_FLAG_OFFSET) : (Byte)0x00;
       index++;
 
       // encode remaining length
-      index = this.encodeRemainingLength(remainingLength, buffer, index);
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
 
       // topic name
       buffer[index++] = (Byte)((topicUtf8.Length >> 8) & 0x00FF); // MSB
@@ -141,22 +138,22 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
       index += topicUtf8.Length;
 
       // message id is valid only with QOS level 1 or QOS level 2
-      if ((this.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) ||
+      if (this.QosLevel == QOS_LEVEL_AT_LEAST_ONCE ||
-          (this.qosLevel == QOS_LEVEL_EXACTLY_ONCE)) {
+          this.QosLevel == QOS_LEVEL_EXACTLY_ONCE) {
         // check message identifier assigned
-        if (this.messageId == 0) {
+        if (this.MessageId == 0) {
           throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
         }
 
-        buffer[index++] = (Byte)((this.messageId >> 8) & 0x00FF); // MSB
+        buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
-        buffer[index++] = (Byte)(this.messageId & 0x00FF); // LSB
+        buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB
       }
 
       // check on message with zero length
       if (this.Message != null) {
         // message data
         Array.Copy(this.Message, 0, buffer, index, this.Message.Length);
-        index += this.Message.Length;
+        _ = this.Message.Length;
       }
 
       return buffer;
@@ -177,14 +174,14 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
       MqttMsgPublish msg = new MqttMsgPublish();
 
       // get remaining length and allocate buffer
-      Int32 remainingLength = decodeRemainingLength(channel);
+      Int32 remainingLength = DecodeRemainingLength(channel);
       buffer = new Byte[remainingLength];
 
       // read bytes from socket...
       Int32 received = channel.Receive(buffer);
 
       // topic name
-      topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+      topicUtf8Length = (buffer[index++] << 8) & 0xFF00;
       topicUtf8Length |= buffer[index++];
       topicUtf8 = new Byte[topicUtf8Length];
       Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
@@ -192,22 +189,22 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
       msg.Topic = new String(Encoding.UTF8.GetChars(topicUtf8));
 
       // read QoS level from fixed header
-      msg.qosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
+      msg.QosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
       // check wrong QoS level (both bits can't be set 1)
-      if (msg.qosLevel > QOS_LEVEL_EXACTLY_ONCE) {
+      if (msg.QosLevel > QOS_LEVEL_EXACTLY_ONCE) {
         throw new MqttClientException(MqttClientErrorCode.QosNotAllowed);
       }
       // read DUP flag from fixed header
-      msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
+      msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01;
       // read retain flag from fixed header
-      msg.retain = (((fixedHeaderFirstByte & RETAIN_FLAG_MASK) >> RETAIN_FLAG_OFFSET) == 0x01);
+      msg.Retain = (fixedHeaderFirstByte & RETAIN_FLAG_MASK) >> RETAIN_FLAG_OFFSET == 0x01;
 
       // message id is valid only with QOS level 1 or QOS level 2
-      if ((msg.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) ||
+      if (msg.QosLevel == QOS_LEVEL_AT_LEAST_ONCE ||
-          (msg.qosLevel == QOS_LEVEL_EXACTLY_ONCE)) {
+          msg.QosLevel == QOS_LEVEL_EXACTLY_ONCE) {
         // message id
-        msg.messageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
+        msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
-        msg.messageId |= (buffer[index++]);
+        msg.MessageId |= buffer[index++];
       }
 
       // get payload with message data
@@ -220,8 +217,8 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
 
       // copy first part of payload data received
       Array.Copy(buffer, index, msg.Message, messageOffset, received - index);
-      remaining -= (received - index);
+      remaining -= received - index;
-      messageOffset += (received - index);
+      messageOffset += received - index;
 
       // if payload isn't finished
       while (remaining > 0) {
@@ -235,15 +232,15 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
       return msg;
     }
 
-    public override String ToString() {
+    public override String ToString() =>
 #if TRACE
-      return this.GetTraceString(
+      this.GetTraceString(
           "PUBLISH",
           new Object[] { "messageId", "topic", "message" },
-          new Object[] { this.messageId, this.Topic, this.Message });
+          new Object[] { this.MessageId, this.Topic, this.Message });
 #else
-            return base.ToString();
+            base.ToString();
 #endif
-    }
+
   }
 }

M2Mqtt/Messages/MqttMsgPublishEventArgs.cs

@@ -14,98 +14,66 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System;
 #else
 using Microsoft.SPOT;
 #endif
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Event Args class for PUBLISH message received from broker
+  /// </summary>
+  public class MqttMsgPublishEventArgs : EventArgs {
+    #region Properties...
+
     /// <summary>
-    /// Event Args class for PUBLISH message received from broker
+    /// Message topic
     /// </summary>
-    public class MqttMsgPublishEventArgs : EventArgs
+    public String Topic { get; internal set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    /// <summary>
-        /// Message topic
+    /// Message data
-        /// </summary>
+    /// </summary>
-        public string Topic
+    public Byte[] Message { get; internal set; }
-        {
-            get { return this.topic; }
-            internal set { this.topic = value; }
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Message data
+    /// Duplicate message flag
-        /// </summary>
+    /// </summary>
-        public byte[] Message
+    public Boolean DupFlag { get; set; }
-        {
-            get { return this.message; }
-            internal set { this.message = value; }
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Duplicate message flag
+    /// Quality of Service level
-        /// </summary>
+    /// </summary>
-        public bool DupFlag
+    public Byte QosLevel { get; internal set; }
-        {
-            get { return this.dupFlag; }
-            set { this.dupFlag = value; }
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Quality of Service level
+    /// Retain message flag
-        /// </summary>
+    /// </summary>
-        public byte QosLevel
+    public Boolean Retain { get; internal set; }
-        {
-            get { return this.qosLevel; }
-            internal set { this.qosLevel = value; }
-        }
 
-        /// <summary>
+    #endregion
-        /// Retain message flag
-        /// </summary>
-        public bool Retain
-        {
-            get { return this.retain; }
-            internal set { this.retain = value; }
-        }
 
-        #endregion
+    // message topic
 
-        // message topic
+    /// <summary>
-        private string topic;
+    /// Constructor
-        // message data
+    /// </summary>
-        private byte[] message;
+    /// <param name="topic">Message topic</param>
-        // duplicate delivery
+    /// <param name="message">Message data</param>
-        private bool dupFlag;
+    /// <param name="dupFlag">Duplicate delivery flag</param>
-        // quality of service level
+    /// <param name="qosLevel">Quality of Service level</param>
-        private byte qosLevel;
+    /// <param name="retain">Retain flag</param>
-        // retain flag
+    public MqttMsgPublishEventArgs(String topic,
-        private bool retain;       
+        Byte[] message,
-
+        Boolean dupFlag,
-        /// <summary>
+        Byte qosLevel,
-        /// Constructor
+        Boolean retain) {
-        /// </summary>
+      this.Topic = topic;
-        /// <param name="topic">Message topic</param>
+      this.Message = message;
-        /// <param name="message">Message data</param>
+      this.DupFlag = dupFlag;
-        /// <param name="dupFlag">Duplicate delivery flag</param>
+      this.QosLevel = qosLevel;
-        /// <param name="qosLevel">Quality of Service level</param>
+      this.Retain = retain;
-        /// <param name="retain">Retain flag</param>
-        public MqttMsgPublishEventArgs(string topic,
-            byte[] message,
-            bool dupFlag,
-            byte qosLevel,
-            bool retain)
-        {
-            this.topic = topic;
-            this.message = message;
-            this.dupFlag = dupFlag;
-            this.qosLevel = qosLevel;
-            this.retain = retain;
-        }
     }
+  }
 }

M2Mqtt/Messages/MqttMsgPublishedEventArgs.cs

@@ -14,65 +14,49 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System;
 #else
 using Microsoft.SPOT;
 #endif
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Event Args class for published message
+  /// </summary>
+  public class MqttMsgPublishedEventArgs : EventArgs {
+    #region Properties...
+
     /// <summary>
-    /// Event Args class for published message
+    /// Message identifier
     /// </summary>
-    public class MqttMsgPublishedEventArgs : EventArgs
+    public UInt16 MessageId { get; internal set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    /// <summary>
-        /// Message identifier
+    /// Message published (or failed due to retries)
-        /// </summary>
+    /// </summary>
-        public ushort MessageId
+    public Boolean IsPublished { get; internal set; }
-        {
-            get { return this.messageId; }
-            internal set { this.messageId = value; }
-        }
 
-        /// <summary>
+    #endregion
-        /// Message published (or failed due to retries)
-        /// </summary>
-        public bool IsPublished
-        {
-            get { return this.isPublished; }
-            internal set { this.isPublished = value; }
-        }
 
-        #endregion
+    // message identifier
 
-        // message identifier
+    /// <summary>
-        ushort messageId;
+    /// Constructor (published message)
-
+    /// </summary>
-        // published flag
+    /// <param name="messageId">Message identifier published</param>
-        bool isPublished;
+    public MqttMsgPublishedEventArgs(UInt16 messageId)
-
+        : this(messageId, true) {
-        /// <summary>
-        /// Constructor (published message)
-        /// </summary>
-        /// <param name="messageId">Message identifier published</param>
-        public MqttMsgPublishedEventArgs(ushort messageId) 
-            : this(messageId, true) 
-        { 
-        }
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="messageId">Message identifier</param>
-        /// <param name="isPublished">Publish flag</param>
-        public MqttMsgPublishedEventArgs(ushort messageId, bool isPublished)
-        {
-            this.messageId = messageId;
-            this.isPublished = isPublished;
-        }
     }
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="messageId">Message identifier</param>
+    /// <param name="isPublished">Publish flag</param>
+    public MqttMsgPublishedEventArgs(UInt16 messageId, Boolean isPublished) {
+      this.MessageId = messageId;
+      this.IsPublished = isPublished;
+    }
+  }
 }

M2Mqtt/Messages/MqttMsgPubrec.cs

@@ -14,112 +14,102 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for PUBREC message from broker to client
+  /// </summary>
+  public class MqttMsgPubrec : MqttMsgBase {
     /// <summary>
-    /// Class for PUBREC message from broker to client
+    /// Constructor
     /// </summary>
-    public class MqttMsgPubrec : MqttMsgBase
+    public MqttMsgPubrec() => this.Type = MQTT_MSG_PUBREC_TYPE;
-    {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public MqttMsgPubrec()
-        {
-            this.type = MQTT_MSG_PUBREC_TYPE;
-        }
 
-        public override byte[] GetBytes(byte protocolVersion)
+    public override Byte[] GetBytes(Byte protocolVersion) {
-        {
+      Int32 varHeaderSize = 0;
-            int fixedHeaderSize = 0;
+      Int32 payloadSize = 0;
-            int varHeaderSize = 0;
+      Int32 remainingLength = 0;
-            int payloadSize = 0;
+      Byte[] buffer;
-            int remainingLength = 0;
+      Int32 index = 0;
-            byte[] buffer;
-            int index = 0;
 
-            // message identifier
+      // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
+      varHeaderSize += MESSAGE_ID_SIZE;
 
-            remainingLength += (varHeaderSize + payloadSize);
+      remainingLength += varHeaderSize + payloadSize;
 
-            // first byte of fixed header
+      // first byte of fixed header
-            fixedHeaderSize = 1;
+      Int32 fixedHeaderSize = 1;
 
-            int temp = remainingLength;
+      Int32 temp = remainingLength;
-            // increase fixed header size based on remaining length
+      // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
+      // (each remaining length byte can encode until 128)
-            do
+      do {
-            {
+        fixedHeaderSize++;
-                fixedHeaderSize++;
+        temp /= 128;
-                temp = temp / 128;
+      } while (temp > 0);
-            } while (temp > 0);
 
-            // allocate buffer for message
+      // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
 
-            // first fixed header byte
+      // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
-                buffer[index++] = (MQTT_MSG_PUBREC_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREC_FLAG_BITS; // [v.3.1.1]
+        ? (Byte)((MQTT_MSG_PUBREC_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREC_FLAG_BITS)
-            else
+        : (Byte)(MQTT_MSG_PUBREC_TYPE << MSG_TYPE_OFFSET);
-                buffer[index++] = (MQTT_MSG_PUBREC_TYPE << MSG_TYPE_OFFSET);
 
-            // encode remaining length
+      // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
 
-            // get message identifier
+      // get message identifier
-            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
+      buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB 
 
-            return buffer;
+      return buffer;
-        }
-
-        /// <summary>
-        /// Parse bytes for a PUBREC message
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>PUBREC message instance</returns>
-        public static MqttMsgPubrec Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            MqttMsgPubrec msg = new MqttMsgPubrec();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREC_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            channel.Receive(buffer);
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            return msg;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "PUBREC",
-                new object[] { "messageId" },
-                new object[] { this.messageId });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    /// <summary>
+    /// Parse bytes for a PUBREC message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>PUBREC message instance</returns>
+    public static MqttMsgPubrec Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      Int32 index = 0;
+      MqttMsgPubrec msg = new MqttMsgPubrec();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREC_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
+        }
+      }
+
+      // get remaining length and allocate buffer
+      Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
+      buffer = new Byte[remainingLength];
+
+      // read bytes from socket...
+      _ = channel.Receive(buffer);
+
+      // message id
+      msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
+      msg.MessageId |= buffer[index++];
+
+      return msg;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "PUBREC",
+          new Object[] { "messageId" },
+          new Object[] { this.MessageId });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgPubrel.cs

@@ -16,127 +16,117 @@ Contributors:
 
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for PUBREL message from client top broker
+  /// </summary>
+  public class MqttMsgPubrel : MqttMsgBase {
     /// <summary>
-    /// Class for PUBREL message from client top broker
+    /// Constructor
     /// </summary>
-    public class MqttMsgPubrel : MqttMsgBase
+    public MqttMsgPubrel() {
-    {
+      this.Type = MQTT_MSG_PUBREL_TYPE;
-        /// <summary>
+      // PUBREL message use QoS Level 1 (not "officially" in 3.1.1)
-        /// Constructor
+      this.QosLevel = QOS_LEVEL_AT_LEAST_ONCE;
-        /// </summary>
-        public MqttMsgPubrel()
-        {
-            this.type = MQTT_MSG_PUBREL_TYPE;
-            // PUBREL message use QoS Level 1 (not "officially" in 3.1.1)
-            this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
-        }
-
-        public override byte[] GetBytes(byte protocolVersion)
-        {
-            int fixedHeaderSize = 0;
-            int varHeaderSize = 0;
-            int payloadSize = 0;
-            int remainingLength = 0;
-            byte[] buffer;
-            int index = 0;
-
-            // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
-
-            remainingLength += (varHeaderSize + payloadSize);
-
-            // first byte of fixed header
-            fixedHeaderSize = 1;
-
-            int temp = remainingLength;
-            // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
-            do
-            {
-                fixedHeaderSize++;
-                temp = temp / 128;
-            } while (temp > 0);
-
-            // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
-
-            // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREL_FLAG_BITS; // [v.3.1.1]
-            else
-            {
-                buffer[index] = (byte)((MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) |
-                                   (this.qosLevel << QOS_LEVEL_OFFSET));
-                buffer[index] |= this.dupFlag ? (byte)(1 << DUP_FLAG_OFFSET) : (byte)0x00;
-                index++;
-            }
-            
-            // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
-
-            // get next message identifier
-            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
-
-            return buffer;
-        }
-
-        /// <summary>
-        /// Parse bytes for a PUBREL message
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>PUBREL message instance</returns>
-        public static MqttMsgPubrel Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            MqttMsgPubrel msg = new MqttMsgPubrel();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREL_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            channel.Receive(buffer);
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1)
-            {
-                // only 3.1.0
-
-                // read QoS level from fixed header (would be QoS Level 1)
-                msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
-                // read DUP flag from fixed header
-                msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
-            }
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            return msg;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "PUBREL",
-                new object[] { "messageId" },
-                new object[] { this.messageId });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override System.Byte[] GetBytes(System.Byte protocolVersion) {
+      System.Int32 varHeaderSize = 0;
+      System.Int32 payloadSize = 0;
+      System.Int32 remainingLength = 0;
+      System.Byte[] buffer;
+      System.Int32 index = 0;
+
+      // message identifier
+      varHeaderSize += MESSAGE_ID_SIZE;
+
+      remainingLength += varHeaderSize + payloadSize;
+
+      // first byte of fixed header
+      System.Int32 fixedHeaderSize = 1;
+
+      System.Int32 temp = remainingLength;
+      // increase fixed header size based on remaining length
+      // (each remaining length byte can encode until 128)
+      do {
+        fixedHeaderSize++;
+        temp /= 128;
+      } while (temp > 0);
+
+      // allocate buffer for message
+      buffer = new System.Byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+      // first fixed header byte
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        buffer[index++] = (MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREL_FLAG_BITS; // [v.3.1.1]
+      } else {
+        buffer[index] = (System.Byte)((MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) |
+                           (this.QosLevel << QOS_LEVEL_OFFSET));
+        buffer[index] |= this.DupFlag ? (System.Byte)(1 << DUP_FLAG_OFFSET) : (System.Byte)0x00;
+        index++;
+      }
+
+      // encode remaining length
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
+
+      // get next message identifier
+      buffer[index++] = (System.Byte)((this.MessageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (System.Byte)(this.MessageId & 0x00FF); // LSB 
+
+      return buffer;
+    }
+
+    /// <summary>
+    /// Parse bytes for a PUBREL message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>PUBREL message instance</returns>
+    public static MqttMsgPubrel Parse(System.Byte fixedHeaderFirstByte, System.Byte protocolVersion, IMqttNetworkChannel channel) {
+      System.Byte[] buffer;
+      System.Int32 index = 0;
+      MqttMsgPubrel msg = new MqttMsgPubrel();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREL_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
+        }
+      }
+
+      // get remaining length and allocate buffer
+      System.Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
+      buffer = new System.Byte[remainingLength];
+
+      // read bytes from socket...
+      _ = channel.Receive(buffer);
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1) {
+        // only 3.1.0
+
+        // read QoS level from fixed header (would be QoS Level 1)
+        msg.QosLevel = (System.Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
+        // read DUP flag from fixed header
+        msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01;
+      }
+
+      // message id
+      msg.MessageId = (System.UInt16)((buffer[index++] << 8) & 0xFF00);
+      msg.MessageId |= buffer[index++];
+
+      return msg;
+    }
+
+    public override System.String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "PUBREL",
+          new System.Object[] { "messageId" },
+          new System.Object[] { this.MessageId });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgSuback.cs

@@ -17,146 +17,127 @@ Contributors:
 using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for SUBACK message from broker to client
+  /// </summary>
+  public class MqttMsgSuback : MqttMsgBase {
+    #region Properties...
+
     /// <summary>
-    /// Class for SUBACK message from broker to client
+    /// List of granted QOS Levels
     /// </summary>
-    public class MqttMsgSuback : MqttMsgBase
+    public Byte[] GrantedQoSLevels { get; set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    #endregion
-        /// List of granted QOS Levels
+
-        /// </summary>
+    // granted QOS levels
-        public byte[] GrantedQoSLevels
+
-        {
+    /// <summary>
-            get { return this.grantedQosLevels; }
+    /// Constructor
-            set { this.grantedQosLevels = value; }
+    /// </summary>
+    public MqttMsgSuback() => this.Type = MQTT_MSG_SUBACK_TYPE;
+
+    /// <summary>
+    /// Parse bytes for a SUBACK message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>SUBACK message instance</returns>
+    public static MqttMsgSuback Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      Int32 index = 0;
+      MqttMsgSuback msg = new MqttMsgSuback();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBACK_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
         }
+      }
 
-        #endregion
+      // get remaining length and allocate buffer
+      Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
+      buffer = new Byte[remainingLength];
 
-        // granted QOS levels
+      // read bytes from socket...
-        byte[] grantedQosLevels;
+      _ = channel.Receive(buffer);
 
-        /// <summary>
+      // message id
-        /// Constructor
+      msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
-        /// </summary>
+      msg.MessageId |= buffer[index++];
-        public MqttMsgSuback()
-        {
-            this.type = MQTT_MSG_SUBACK_TYPE;
-        }
 
-        /// <summary>
+      // payload contains QoS levels granted
-        /// Parse bytes for a SUBACK message
+      msg.GrantedQoSLevels = new Byte[remainingLength - MESSAGE_ID_SIZE];
-        /// </summary>
+      Int32 qosIdx = 0;
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+      do {
-        /// <param name="protocolVersion">Protocol Version</param>
+        msg.GrantedQoSLevels[qosIdx++] = buffer[index++];
-        /// <param name="channel">Channel connected to the broker</param>
+      } while (index < remainingLength);
-        /// <returns>SUBACK message instance</returns>
-        public static MqttMsgSuback Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            MqttMsgSuback msg = new MqttMsgSuback();
 
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      return msg;
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBACK_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            channel.Receive(buffer);
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            // payload contains QoS levels granted
-            msg.grantedQosLevels = new byte[remainingLength - MESSAGE_ID_SIZE];
-            int qosIdx = 0;
-            do
-            {
-                msg.grantedQosLevels[qosIdx++] = buffer[index++];
-            } while (index < remainingLength);
-
-            return msg;
-        }
-
-        public override byte[] GetBytes(byte protocolVersion)
-        {
-            int fixedHeaderSize = 0;
-            int varHeaderSize = 0;
-            int payloadSize = 0;
-            int remainingLength = 0;
-            byte[] buffer;
-            int index = 0;
-
-            // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
-
-            int grantedQosIdx = 0;
-            for (grantedQosIdx = 0; grantedQosIdx < this.grantedQosLevels.Length; grantedQosIdx++)
-            {
-                payloadSize++;
-            }
-
-            remainingLength += (varHeaderSize + payloadSize);
-
-            // first byte of fixed header
-            fixedHeaderSize = 1;
-
-            int temp = remainingLength;
-            // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
-            do
-            {
-                fixedHeaderSize++;
-                temp = temp / 128;
-            } while (temp > 0);
-
-            // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
-
-            // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBACK_FLAG_BITS; // [v.3.1.1]
-            else
-                buffer[index++] = (byte)(MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET);
-            
-            // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
-
-            // message id
-            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB
-
-            // payload contains QoS levels granted
-            for (grantedQosIdx = 0; grantedQosIdx < this.grantedQosLevels.Length; grantedQosIdx++)
-            {
-                buffer[index++] = this.grantedQosLevels[grantedQosIdx];
-            }
-
-            return buffer;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "SUBACK",
-                new object[] { "messageId", "grantedQosLevels" },
-                new object[] { this.messageId, this.grantedQosLevels });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override Byte[] GetBytes(Byte protocolVersion) {
+      Int32 varHeaderSize = 0;
+      Int32 payloadSize = 0;
+      Int32 remainingLength = 0;
+      Byte[] buffer;
+      Int32 index = 0;
+
+      // message identifier
+      varHeaderSize += MESSAGE_ID_SIZE;
+
+      Int32 grantedQosIdx;
+      for (grantedQosIdx = 0; grantedQosIdx < this.GrantedQoSLevels.Length; grantedQosIdx++) {
+        payloadSize++;
+      }
+
+      remainingLength += varHeaderSize + payloadSize;
+
+      // first byte of fixed header
+      Int32 fixedHeaderSize = 1;
+
+      Int32 temp = remainingLength;
+      // increase fixed header size based on remaining length
+      // (each remaining length byte can encode until 128)
+      do {
+        fixedHeaderSize++;
+        temp /= 128;
+      } while (temp > 0);
+
+      // allocate buffer for message
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+      // first fixed header byte
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
+        ? (Byte)((MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBACK_FLAG_BITS)
+        : (Byte)(MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET);
+
+      // encode remaining length
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
+
+      // message id
+      buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB
+
+      // payload contains QoS levels granted
+      for (grantedQosIdx = 0; grantedQosIdx < this.GrantedQoSLevels.Length; grantedQosIdx++) {
+        buffer[index++] = this.GrantedQoSLevels[grantedQosIdx];
+      }
+
+      return buffer;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "SUBACK",
+          new Object[] { "messageId", "grantedQosLevels" },
+          new Object[] { this.MessageId, this.GrantedQoSLevels });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgSubscribe.cs

@@ -16,257 +16,234 @@ Contributors:
 
 using System;
 // if NOT .Net Micro Framework
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System.Collections.Generic;
 #endif
 using System.Collections;
 using System.Text;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for SUBSCRIBE message from client to broker
+  /// </summary>
+  public class MqttMsgSubscribe : MqttMsgBase {
+    #region Properties...
+
     /// <summary>
-    /// Class for SUBSCRIBE message from client to broker
+    /// List of topics to subscribe
     /// </summary>
-    public class MqttMsgSubscribe : MqttMsgBase
+    public String[] Topics { get; set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    /// <summary>
-        /// List of topics to subscribe
+    /// List of QOS Levels related to topics
-        /// </summary>
+    /// </summary>
-        public string[] Topics
+    public Byte[] QoSLevels { get; set; }
-        {
+
-            get { return this.topics; }
+    #endregion
-            set { this.topics = value; }
+
+    // topics to subscribe
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    public MqttMsgSubscribe() => this.Type = MQTT_MSG_SUBSCRIBE_TYPE;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="topics">List of topics to subscribe</param>
+    /// <param name="qosLevels">List of QOS Levels related to topics</param>
+    public MqttMsgSubscribe(String[] topics, Byte[] qosLevels) {
+      this.Type = MQTT_MSG_SUBSCRIBE_TYPE;
+
+      this.Topics = topics;
+      this.QoSLevels = qosLevels;
+
+      // SUBSCRIBE message uses QoS Level 1 (not "officially" in 3.1.1)
+      this.QosLevel = QOS_LEVEL_AT_LEAST_ONCE;
+    }
+
+    /// <summary>
+    /// Parse bytes for a SUBSCRIBE message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>SUBSCRIBE message instance</returns>
+    public static MqttMsgSubscribe Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      Int32 index = 0;
+      Byte[] topicUtf8;
+      Int32 topicUtf8Length;
+      MqttMsgSubscribe msg = new MqttMsgSubscribe();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBSCRIBE_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
         }
+      }
 
-        /// <summary>
+      // get remaining length and allocate buffer
-        /// List of QOS Levels related to topics
+      Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
-        /// </summary>
+      buffer = new Byte[remainingLength];
-        public byte[] QoSLevels
-        {
-            get { return this.qosLevels; }
-            set { this.qosLevels = value; }
-        }
 
-        #endregion
+      // read bytes from socket...
+      Int32 received = channel.Receive(buffer);
 
-        // topics to subscribe
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1) {
-        string[] topics;
+        // only 3.1.0
-        // QOS levels related to topics
-        byte[] qosLevels;
 
-        /// <summary>
+        // read QoS level from fixed header
-        /// Constructor
+        msg.QosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
-        /// </summary>
+        // read DUP flag from fixed header
-        public MqttMsgSubscribe()
+        msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01;
-        {
+        // retain flag not used
-            this.type = MQTT_MSG_SUBSCRIBE_TYPE;
+        msg.Retain = false;
-        }
+      }
 
-        /// <summary>
+      // message id
-        /// Constructor
+      msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
-        /// </summary>
+      msg.MessageId |= buffer[index++];
-        /// <param name="topics">List of topics to subscribe</param>
-        /// <param name="qosLevels">List of QOS Levels related to topics</param>
-        public MqttMsgSubscribe(string[] topics, byte[] qosLevels)
-        {
-            this.type = MQTT_MSG_SUBSCRIBE_TYPE;
 
-            this.topics = topics;
+      // payload contains topics and QoS levels
-            this.qosLevels = qosLevels;
+      // NOTE : before, I don't know how many topics will be in the payload (so use List)
 
-            // SUBSCRIBE message uses QoS Level 1 (not "officially" in 3.1.1)
+      // if .Net Micro Framework
-            this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
-        }
-
-        /// <summary>
-        /// Parse bytes for a SUBSCRIBE message
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>SUBSCRIBE message instance</returns>
-        public static MqttMsgSubscribe Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            byte[] topicUtf8;
-            int topicUtf8Length;
-            MqttMsgSubscribe msg = new MqttMsgSubscribe();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBSCRIBE_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            int received = channel.Receive(buffer);
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1)
-            {
-                // only 3.1.0
-
-                // read QoS level from fixed header
-                msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
-                // read DUP flag from fixed header
-                msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
-                // retain flag not used
-                msg.retain = false;
-            }
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            // payload contains topics and QoS levels
-            // NOTE : before, I don't know how many topics will be in the payload (so use List)
-
-// if .Net Micro Framework
-#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
             IList tmpTopics = new ArrayList();
             IList tmpQosLevels = new ArrayList();
 // else other frameworks (.Net, .Net Compact, Mono, Windows Phone) 
 #else
-            IList<String> tmpTopics = new List<String>();
+      IList<String> tmpTopics = new List<String>();
-            IList<byte> tmpQosLevels = new List<byte>();
+      IList<Byte> tmpQosLevels = new List<Byte>();
 #endif
-            do
+      do {
-            {
+        // topic name
-                // topic name
+        topicUtf8Length = (buffer[index++] << 8) & 0xFF00;
-                topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+        topicUtf8Length |= buffer[index++];
-                topicUtf8Length |= buffer[index++];
+        topicUtf8 = new Byte[topicUtf8Length];
-                topicUtf8 = new byte[topicUtf8Length];
+        Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
-                Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
+        index += topicUtf8Length;
-                index += topicUtf8Length;
+        tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
-                tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
 
-                // QoS level
+        // QoS level
-                tmpQosLevels.Add(buffer[index++]);
+        tmpQosLevels.Add(buffer[index++]);
 
-            } while (index < remainingLength);
+      } while (index < remainingLength);
 
-            // copy from list to array
+      // copy from list to array
-            msg.topics = new string[tmpTopics.Count];
+      msg.Topics = new String[tmpTopics.Count];
-            msg.qosLevels = new byte[tmpQosLevels.Count];
+      msg.QoSLevels = new Byte[tmpQosLevels.Count];
-            for (int i = 0; i < tmpTopics.Count; i++)
+      for (Int32 i = 0; i < tmpTopics.Count; i++) {
-            {
+        msg.Topics[i] = (String)tmpTopics[i];
-                msg.topics[i] = (string)tmpTopics[i];
+        msg.QoSLevels[i] = (Byte)tmpQosLevels[i];
-                msg.qosLevels[i] = (byte)tmpQosLevels[i];
+      }
-            }
 
-            return msg;
+      return msg;
-        }
-
-        public override byte[] GetBytes(byte protocolVersion)
-        {
-            int fixedHeaderSize = 0;
-            int varHeaderSize = 0;
-            int payloadSize = 0;
-            int remainingLength = 0;
-            byte[] buffer;
-            int index = 0;
-
-            // topics list empty
-            if ((this.topics == null) || (this.topics.Length == 0))
-                throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
-
-            // qos levels list empty
-            if ((this.qosLevels == null) || (this.qosLevels.Length == 0))
-                throw new MqttClientException(MqttClientErrorCode.QosLevelsEmpty);
-
-            // topics and qos levels lists length don't match
-            if (this.topics.Length != this.qosLevels.Length)
-                throw new MqttClientException(MqttClientErrorCode.TopicsQosLevelsNotMatch);
-
-            // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
-
-            int topicIdx = 0;
-            byte[][] topicsUtf8 = new byte[this.topics.Length][];
-
-            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
-            {
-                // check topic length
-                if ((this.topics[topicIdx].Length < MIN_TOPIC_LENGTH) || (this.topics[topicIdx].Length > MAX_TOPIC_LENGTH))
-                    throw new MqttClientException(MqttClientErrorCode.TopicLength);
-
-                topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.topics[topicIdx]);
-                payloadSize += 2; // topic size (MSB, LSB)
-                payloadSize += topicsUtf8[topicIdx].Length;
-                payloadSize++; // byte for QoS
-            }
-
-            remainingLength += (varHeaderSize + payloadSize);
-
-            // first byte of fixed header
-            fixedHeaderSize = 1;
-
-            int temp = remainingLength;
-            // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
-            do
-            {
-                fixedHeaderSize++;
-                temp = temp / 128;
-            } while (temp > 0);
-
-            // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
-
-            // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_SUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBSCRIBE_FLAG_BITS; // [v.3.1.1]
-            else
-            {
-                buffer[index] = (byte)((MQTT_MSG_SUBSCRIBE_TYPE << MSG_TYPE_OFFSET) |
-                                   (this.qosLevel << QOS_LEVEL_OFFSET));
-                buffer[index] |= this.dupFlag ? (byte)(1 << DUP_FLAG_OFFSET) : (byte)0x00;
-                index++;
-            }
-            
-            // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
-
-            // check message identifier assigned (SUBSCRIBE uses QoS Level 1, so message id is mandatory)
-            if (this.messageId == 0)
-                throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
-            buffer[index++] = (byte)((messageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(messageId & 0x00FF); // LSB 
-
-            topicIdx = 0;
-            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
-            {
-                // topic name
-                buffer[index++] = (byte)((topicsUtf8[topicIdx].Length >> 8) & 0x00FF); // MSB
-                buffer[index++] = (byte)(topicsUtf8[topicIdx].Length & 0x00FF); // LSB
-                Array.Copy(topicsUtf8[topicIdx], 0, buffer, index, topicsUtf8[topicIdx].Length);
-                index += topicsUtf8[topicIdx].Length;
-
-                // requested QoS
-                buffer[index++] = this.qosLevels[topicIdx];
-            }
-            
-            return buffer;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "SUBSCRIBE",
-                new object[] { "messageId", "topics", "qosLevels" },
-                new object[] { this.messageId, this.topics, this.qosLevels });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override Byte[] GetBytes(Byte protocolVersion) {
+      Int32 varHeaderSize = 0;
+      Int32 payloadSize = 0;
+      Int32 remainingLength = 0;
+      Byte[] buffer;
+      Int32 index = 0;
+
+      // topics list empty
+      if (this.Topics == null || this.Topics.Length == 0) {
+        throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
+      }
+
+      // qos levels list empty
+      if (this.QoSLevels == null || this.QoSLevels.Length == 0) {
+        throw new MqttClientException(MqttClientErrorCode.QosLevelsEmpty);
+      }
+
+      // topics and qos levels lists length don't match
+      if (this.Topics.Length != this.QoSLevels.Length) {
+        throw new MqttClientException(MqttClientErrorCode.TopicsQosLevelsNotMatch);
+      }
+
+      // message identifier
+      varHeaderSize += MESSAGE_ID_SIZE;
+      Byte[][] topicsUtf8 = new Byte[this.Topics.Length][];
+
+
+      Int32 topicIdx;
+      for (topicIdx = 0; topicIdx < this.Topics.Length; topicIdx++) {
+        // check topic length
+        if (this.Topics[topicIdx].Length < MIN_TOPIC_LENGTH || this.Topics[topicIdx].Length > MAX_TOPIC_LENGTH) {
+          throw new MqttClientException(MqttClientErrorCode.TopicLength);
+        }
+
+        topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.Topics[topicIdx]);
+        payloadSize += 2; // topic size (MSB, LSB)
+        payloadSize += topicsUtf8[topicIdx].Length;
+        payloadSize++; // byte for QoS
+      }
+
+      remainingLength += varHeaderSize + payloadSize;
+
+      // first byte of fixed header
+      Int32 fixedHeaderSize = 1;
+
+      Int32 temp = remainingLength;
+      // increase fixed header size based on remaining length
+      // (each remaining length byte can encode until 128)
+      do {
+        fixedHeaderSize++;
+        temp /= 128;
+      } while (temp > 0);
+
+      // allocate buffer for message
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+      // first fixed header byte
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        buffer[index++] = (MQTT_MSG_SUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBSCRIBE_FLAG_BITS; // [v.3.1.1]
+      } else {
+        buffer[index] = (Byte)((MQTT_MSG_SUBSCRIBE_TYPE << MSG_TYPE_OFFSET) |
+                           (this.QosLevel << QOS_LEVEL_OFFSET));
+        buffer[index] |= this.DupFlag ? (Byte)(1 << DUP_FLAG_OFFSET) : (Byte)0x00;
+        index++;
+      }
+
+      // encode remaining length
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
+
+      // check message identifier assigned (SUBSCRIBE uses QoS Level 1, so message id is mandatory)
+      if (this.MessageId == 0) {
+        throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
+      }
+
+      buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB 
+
+      for (topicIdx = 0; topicIdx < this.Topics.Length; topicIdx++) {
+        // topic name
+        buffer[index++] = (Byte)((topicsUtf8[topicIdx].Length >> 8) & 0x00FF); // MSB
+        buffer[index++] = (Byte)(topicsUtf8[topicIdx].Length & 0x00FF); // LSB
+        Array.Copy(topicsUtf8[topicIdx], 0, buffer, index, topicsUtf8[topicIdx].Length);
+        index += topicsUtf8[topicIdx].Length;
+
+        // requested QoS
+        buffer[index++] = this.QoSLevels[topicIdx];
+      }
+
+      return buffer;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "SUBSCRIBE",
+          new Object[] { "messageId", "topics", "qosLevels" },
+          new Object[] { this.MessageId, this.Topics, this.QoSLevels });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgSubscribeEventArgs.cs

@@ -14,68 +14,48 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System;
 #else
 using Microsoft.SPOT;
 #endif
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Event Args class for subscribe request on topics
+  /// </summary>
+  public class MqttMsgSubscribeEventArgs : EventArgs {
+    #region Properties...
+
     /// <summary>
-    /// Event Args class for subscribe request on topics
+    /// Message identifier
     /// </summary>
-    public class MqttMsgSubscribeEventArgs : EventArgs
+    public UInt16 MessageId { get; internal set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    /// <summary>
-        /// Message identifier
+    /// Topics requested to subscribe
-        /// </summary>
+    /// </summary>
-        public ushort MessageId
+    public String[] Topics { get; internal set; }
-        {
-            get { return this.messageId; }
-            internal set { this.messageId = value; }
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Topics requested to subscribe
+    /// List of QOS Levels requested
-        /// </summary>
+    /// </summary>
-        public string[] Topics
+    public Byte[] QoSLevels { get; internal set; }
-        {
-            get { return this.topics; }
-            internal set { this.topics = value; }
-        }
 
-        /// <summary>
+    #endregion
-        /// List of QOS Levels requested
-        /// </summary>
-        public byte[] QoSLevels
-        {
-            get { return this.qosLevels; }
-            internal set { this.qosLevels = value; }
-        }
 
-        #endregion
+    // message identifier
 
-        // message identifier
+    /// <summary>
-        ushort messageId;
+    /// Constructor
-        // topics requested to subscribe
+    /// </summary>
-        string[] topics;
+    /// <param name="messageId">Message identifier for subscribe topics request</param>
-        // QoS levels requested
+    /// <param name="topics">Topics requested to subscribe</param>
-        byte[] qosLevels;
+    /// <param name="qosLevels">List of QOS Levels requested</param>
-
+    public MqttMsgSubscribeEventArgs(UInt16 messageId, String[] topics, Byte[] qosLevels) {
-        /// <summary>
+      this.MessageId = messageId;
-        /// Constructor
+      this.Topics = topics;
-        /// </summary>
+      this.QoSLevels = qosLevels;
-        /// <param name="messageId">Message identifier for subscribe topics request</param>
-        /// <param name="topics">Topics requested to subscribe</param>
-        /// <param name="qosLevels">List of QOS Levels requested</param>
-        public MqttMsgSubscribeEventArgs(ushort messageId, string[] topics, byte[] qosLevels)
-        {
-            this.messageId = messageId;
-            this.topics = topics;
-            this.qosLevels = qosLevels;
-        }
     }
+  }
 }

M2Mqtt/Messages/MqttMsgSubscribedEventArgs.cs

@@ -14,55 +14,41 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System;
 #else
 using Microsoft.SPOT;
 #endif
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Event Args class for subscribed topics
+  /// </summary>
+  public class MqttMsgSubscribedEventArgs : EventArgs {
+    #region Properties...
+
     /// <summary>
-    /// Event Args class for subscribed topics
+    /// Message identifier
     /// </summary>
-    public class MqttMsgSubscribedEventArgs : EventArgs
+    public UInt16 MessageId { get; internal set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    /// <summary>
-        /// Message identifier
+    /// List of granted QOS Levels
-        /// </summary>
+    /// </summary>
-        public ushort MessageId
+    public Byte[] GrantedQoSLevels { get; internal set; }
-        {
-            get { return this.messageId; }
-            internal set { this.messageId = value; }
-        }
 
-        /// <summary>
+    #endregion
-        /// List of granted QOS Levels
-        /// </summary>
-        public byte[] GrantedQoSLevels
-        {
-            get { return this.grantedQosLevels; }
-            internal set { this.grantedQosLevels = value; }
-        }
 
-        #endregion
+    // message identifier
 
-        // message identifier
+    /// <summary>
-        ushort messageId;
+    /// Constructor
-        // granted QOS levels
+    /// </summary>
-        byte[] grantedQosLevels;
+    /// <param name="messageId">Message identifier for subscribed topics</param>
-
+    /// <param name="grantedQosLevels">List of granted QOS Levels</param>
-        /// <summary>
+    public MqttMsgSubscribedEventArgs(UInt16 messageId, Byte[] grantedQosLevels) {
-        /// Constructor
+      this.MessageId = messageId;
-        /// </summary>
+      this.GrantedQoSLevels = grantedQosLevels;
-        /// <param name="messageId">Message identifier for subscribed topics</param>
-        /// <param name="grantedQosLevels">List of granted QOS Levels</param>
-        public MqttMsgSubscribedEventArgs(ushort messageId, byte[] grantedQosLevels)
-        {
-            this.messageId = messageId;
-            this.grantedQosLevels = grantedQosLevels;
-        }
     }
+  }
 }

M2Mqtt/Messages/MqttMsgUnsuback.cs

@@ -17,110 +17,99 @@ Contributors:
 using System;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for UNSUBACK message from broker to client
+  /// </summary>
+  public class MqttMsgUnsuback : MqttMsgBase {
     /// <summary>
-    /// Class for UNSUBACK message from broker to client
+    /// Constructor
     /// </summary>
-    public class MqttMsgUnsuback : MqttMsgBase
+    public MqttMsgUnsuback() => this.Type = MQTT_MSG_UNSUBACK_TYPE;
-    {
+
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Parse bytes for a UNSUBACK message
-        /// </summary>
+    /// </summary>
-        public MqttMsgUnsuback()
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        {
+    /// <param name="protocolVersion">Protocol Version</param>
-            this.type = MQTT_MSG_UNSUBACK_TYPE;
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>UNSUBACK message instance</returns>
+    public static MqttMsgUnsuback Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      Int32 index = 0;
+      MqttMsgUnsuback msg = new MqttMsgUnsuback();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBACK_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
         }
+      }
 
-        /// <summary>
+      // get remaining length and allocate buffer
-        /// Parse bytes for a UNSUBACK message
+      Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
-        /// </summary>
+      buffer = new Byte[remainingLength];
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>UNSUBACK message instance</returns>
-        public static MqttMsgUnsuback Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            MqttMsgUnsuback msg = new MqttMsgUnsuback();
 
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
+      // read bytes from socket...
-            {
+      _ = channel.Receive(buffer);
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBACK_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
 
-            // get remaining length and allocate buffer
+      // message id
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+      msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
-            buffer = new byte[remainingLength];
+      msg.MessageId |= buffer[index++];
 
-            // read bytes from socket...
+      return msg;
-            channel.Receive(buffer);
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            return msg;
-        }
-
-        public override byte[] GetBytes(byte protocolVersion)
-        {
-            int fixedHeaderSize = 0;
-            int varHeaderSize = 0;
-            int payloadSize = 0;
-            int remainingLength = 0;
-            byte[] buffer;
-            int index = 0;
-
-            // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
-
-            remainingLength += (varHeaderSize + payloadSize);
-
-            // first byte of fixed header
-            fixedHeaderSize = 1;
-
-            int temp = remainingLength;
-            // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
-            do
-            {
-                fixedHeaderSize++;
-                temp = temp / 128;
-            } while (temp > 0);
-
-            // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
-
-            // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBACK_FLAG_BITS; // [v.3.1.1]
-            else
-                buffer[index++] = (byte)(MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET);
-            
-            // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
-
-            // message id
-            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB
-
-            return buffer;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "UNSUBACK",
-                new object[] { "messageId" },
-                new object[] { this.messageId });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override Byte[] GetBytes(Byte protocolVersion) {
+      Int32 varHeaderSize = 0;
+      Int32 payloadSize = 0;
+      Int32 remainingLength = 0;
+      Byte[] buffer;
+      Int32 index = 0;
+
+      // message identifier
+      varHeaderSize += MESSAGE_ID_SIZE;
+
+      remainingLength += varHeaderSize + payloadSize;
+
+      // first byte of fixed header
+      Int32 fixedHeaderSize = 1;
+
+      Int32 temp = remainingLength;
+      // increase fixed header size based on remaining length
+      // (each remaining length byte can encode until 128)
+      do {
+        fixedHeaderSize++;
+        temp /= 128;
+      } while (temp > 0);
+
+      // allocate buffer for message
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+      // first fixed header byte
+      buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
+        ? (Byte)((MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBACK_FLAG_BITS)
+        : (Byte)(MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET);
+
+      // encode remaining length
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
+
+      // message id
+      buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB
+
+      return buffer;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "UNSUBACK",
+          new Object[] { "messageId" },
+          new Object[] { this.MessageId });
+#else
+            base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgUnsubscribe.cs

@@ -16,224 +16,205 @@ Contributors:
 
 using System;
 // if NOT .Net Micro Framework
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System.Collections.Generic;
 #endif
 using System.Collections;
 using System.Text;
 using uPLibrary.Networking.M2Mqtt.Exceptions;
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Class for UNSUBSCRIBE message from client to broker
+  /// </summary>
+  public class MqttMsgUnsubscribe : MqttMsgBase {
+    #region Properties...
+
     /// <summary>
-    /// Class for UNSUBSCRIBE message from client to broker
+    /// List of topics to unsubscribe
     /// </summary>
-    public class MqttMsgUnsubscribe : MqttMsgBase
+    public String[] Topics { get; set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    #endregion
-        /// List of topics to unsubscribe
+
-        /// </summary>
+    // topics to unsubscribe
-        public string[] Topics
+
-        {
+    /// <summary>
-            get { return this.topics; }
+    /// Constructor
-            set { this.topics = value; }
+    /// </summary>
+    public MqttMsgUnsubscribe() => this.Type = MQTT_MSG_UNSUBSCRIBE_TYPE;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="topics">List of topics to unsubscribe</param>
+    public MqttMsgUnsubscribe(String[] topics) {
+      this.Type = MQTT_MSG_UNSUBSCRIBE_TYPE;
+
+      this.Topics = topics;
+
+      // UNSUBSCRIBE message uses QoS Level 1 (not "officially" in 3.1.1)
+      this.QosLevel = QOS_LEVEL_AT_LEAST_ONCE;
+    }
+
+    /// <summary>
+    /// Parse bytes for a UNSUBSCRIBE message
+    /// </summary>
+    /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+    /// <param name="protocolVersion">Protocol Version</param>
+    /// <param name="channel">Channel connected to the broker</param>
+    /// <returns>UNSUBSCRIBE message instance</returns>
+    public static MqttMsgUnsubscribe Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
+      Byte[] buffer;
+      Int32 index = 0;
+      Byte[] topicUtf8;
+      Int32 topicUtf8Length;
+      MqttMsgUnsubscribe msg = new MqttMsgUnsubscribe();
+
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        // [v3.1.1] check flag bits
+        if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBSCRIBE_FLAG_BITS) {
+          throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
         }
+      }
 
-        #endregion
+      // get remaining length and allocate buffer
+      Int32 remainingLength = DecodeRemainingLength(channel);
+      buffer = new Byte[remainingLength];
 
-        // topics to unsubscribe
+      // read bytes from socket...
-        string[] topics;
+      Int32 received = channel.Receive(buffer);
 
-        /// <summary>
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1) {
-        /// Constructor
+        // only 3.1.0
-        /// </summary>
-        public MqttMsgUnsubscribe()
-        {
-            this.type = MQTT_MSG_UNSUBSCRIBE_TYPE;
-        }
 
-        /// <summary>
+        // read QoS level from fixed header
-        /// Constructor
+        msg.QosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
-        /// </summary>
+        // read DUP flag from fixed header
-        /// <param name="topics">List of topics to unsubscribe</param>
+        msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01;
-        public MqttMsgUnsubscribe(string[] topics)
+        // retain flag not used
-        {
+        msg.Retain = false;
-            this.type = MQTT_MSG_UNSUBSCRIBE_TYPE;
+      }
 
-            this.topics = topics;
+      // message id
+      msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
+      msg.MessageId |= buffer[index++];
 
-            // UNSUBSCRIBE message uses QoS Level 1 (not "officially" in 3.1.1)
+      // payload contains topics
-            this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
+      // NOTE : before, I don't know how many topics will be in the payload (so use List)
-        }
 
-        /// <summary>
+      // if .Net Micro Framework
-        /// Parse bytes for a UNSUBSCRIBE message
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
-        /// </summary>
-        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
-        /// <param name="protocolVersion">Protocol Version</param>
-        /// <param name="channel">Channel connected to the broker</param>
-        /// <returns>UNSUBSCRIBE message instance</returns>
-        public static MqttMsgUnsubscribe Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
-        {
-            byte[] buffer;
-            int index = 0;
-            byte[] topicUtf8;
-            int topicUtf8Length;
-            MqttMsgUnsubscribe msg = new MqttMsgUnsubscribe();
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-            {
-                // [v3.1.1] check flag bits
-                if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBSCRIBE_FLAG_BITS)
-                    throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
-            }
-
-            // get remaining length and allocate buffer
-            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
-            buffer = new byte[remainingLength];
-
-            // read bytes from socket...
-            int received = channel.Receive(buffer);
-
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1)
-            {
-                // only 3.1.0
-
-                // read QoS level from fixed header
-                msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
-                // read DUP flag from fixed header
-                msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
-                // retain flag not used
-                msg.retain = false;
-            }
-
-            // message id
-            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
-            msg.messageId |= (buffer[index++]);
-
-            // payload contains topics
-            // NOTE : before, I don't know how many topics will be in the payload (so use List)
-
-// if .Net Micro Framework
-#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
             IList tmpTopics = new ArrayList();
 // else other frameworks (.Net, .Net Compact, Mono, Windows Phone) 
 #else
-            IList<String> tmpTopics = new List<String>();
+      IList<String> tmpTopics = new List<String>();
 #endif
-            do
+      do {
-            {
+        // topic name
-                // topic name
+        topicUtf8Length = (buffer[index++] << 8) & 0xFF00;
-                topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+        topicUtf8Length |= buffer[index++];
-                topicUtf8Length |= buffer[index++];
+        topicUtf8 = new Byte[topicUtf8Length];
-                topicUtf8 = new byte[topicUtf8Length];
+        Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
-                Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
+        index += topicUtf8Length;
-                index += topicUtf8Length;
+        tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
-                tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
+      } while (index < remainingLength);
-            } while (index < remainingLength);
 
-            // copy from list to array
+      // copy from list to array
-            msg.topics = new string[tmpTopics.Count];
+      msg.Topics = new String[tmpTopics.Count];
-            for (int i = 0; i < tmpTopics.Count; i++)
+      for (Int32 i = 0; i < tmpTopics.Count; i++) {
-            {
+        msg.Topics[i] = (String)tmpTopics[i];
-                msg.topics[i] = (string)tmpTopics[i];
+      }
-            }
 
-            return msg;
+      return msg;
-        }
-
-        public override byte[] GetBytes(byte protocolVersion)
-        {
-            int fixedHeaderSize = 0;
-            int varHeaderSize = 0;
-            int payloadSize = 0;
-            int remainingLength = 0;
-            byte[] buffer;
-            int index = 0;
-
-            // topics list empty
-            if ((this.topics == null) || (this.topics.Length == 0))
-                throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
-
-            // message identifier
-            varHeaderSize += MESSAGE_ID_SIZE;
-
-            int topicIdx = 0;
-            byte[][] topicsUtf8 = new byte[this.topics.Length][];
-
-            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
-            {
-                // check topic length
-                if ((this.topics[topicIdx].Length < MIN_TOPIC_LENGTH) || (this.topics[topicIdx].Length > MAX_TOPIC_LENGTH))
-                    throw new MqttClientException(MqttClientErrorCode.TopicLength);
-
-                topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.topics[topicIdx]);
-                payloadSize += 2; // topic size (MSB, LSB)
-                payloadSize += topicsUtf8[topicIdx].Length;
-            }
-
-            remainingLength += (varHeaderSize + payloadSize);
-
-            // first byte of fixed header
-            fixedHeaderSize = 1;
-
-            int temp = remainingLength;
-            // increase fixed header size based on remaining length
-            // (each remaining length byte can encode until 128)
-            do
-            {
-                fixedHeaderSize++;
-                temp = temp / 128;
-            } while (temp > 0);
-
-            // allocate buffer for message
-            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
-
-            // first fixed header byte
-            if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
-                buffer[index++] = (MQTT_MSG_UNSUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBSCRIBE_FLAG_BITS; // [v.3.1.1]
-            else
-            {
-                buffer[index] = (byte)((MQTT_MSG_UNSUBSCRIBE_TYPE << MSG_TYPE_OFFSET) |
-                                   (this.qosLevel << QOS_LEVEL_OFFSET));
-                buffer[index] |= this.dupFlag ? (byte)(1 << DUP_FLAG_OFFSET) : (byte)0x00;
-                index++;
-            }
-            
-            // encode remaining length
-            index = this.encodeRemainingLength(remainingLength, buffer, index);
-
-            // check message identifier assigned
-            if (this.messageId == 0)
-                throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
-            buffer[index++] = (byte)((messageId >> 8) & 0x00FF); // MSB
-            buffer[index++] = (byte)(messageId & 0x00FF); // LSB 
-
-            topicIdx = 0;
-            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
-            {
-                // topic name
-                buffer[index++] = (byte)((topicsUtf8[topicIdx].Length >> 8) & 0x00FF); // MSB
-                buffer[index++] = (byte)(topicsUtf8[topicIdx].Length & 0x00FF); // LSB
-                Array.Copy(topicsUtf8[topicIdx], 0, buffer, index, topicsUtf8[topicIdx].Length);
-                index += topicsUtf8[topicIdx].Length;
-            }
-            
-            return buffer;
-        }
-
-        public override string ToString()
-        {
-#if TRACE
-            return this.GetTraceString(
-                "UNSUBSCRIBE",
-                new object[] { "messageId", "topics" },
-                new object[] { this.messageId, this.topics });
-#else
-            return base.ToString();
-#endif
-        }
     }
+
+    public override Byte[] GetBytes(Byte protocolVersion) {
+      Int32 varHeaderSize = 0;
+      Int32 payloadSize = 0;
+      Int32 remainingLength = 0;
+      Byte[] buffer;
+      Int32 index = 0;
+
+      // topics list empty
+      if (this.Topics == null || this.Topics.Length == 0) {
+        throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
+      }
+
+      // message identifier
+      varHeaderSize += MESSAGE_ID_SIZE;
+      Byte[][] topicsUtf8 = new Byte[this.Topics.Length][];
+
+
+      Int32 topicIdx;
+      for (topicIdx = 0; topicIdx < this.Topics.Length; topicIdx++) {
+        // check topic length
+        if (this.Topics[topicIdx].Length < MIN_TOPIC_LENGTH || this.Topics[topicIdx].Length > MAX_TOPIC_LENGTH) {
+          throw new MqttClientException(MqttClientErrorCode.TopicLength);
+        }
+
+        topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.Topics[topicIdx]);
+        payloadSize += 2; // topic size (MSB, LSB)
+        payloadSize += topicsUtf8[topicIdx].Length;
+      }
+
+      remainingLength += varHeaderSize + payloadSize;
+
+      // first byte of fixed header
+      Int32 fixedHeaderSize = 1;
+
+      Int32 temp = remainingLength;
+      // increase fixed header size based on remaining length
+      // (each remaining length byte can encode until 128)
+      do {
+        fixedHeaderSize++;
+        temp /= 128;
+      } while (temp > 0);
+
+      // allocate buffer for message
+      buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+      // first fixed header byte
+      if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
+        buffer[index++] = (MQTT_MSG_UNSUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBSCRIBE_FLAG_BITS; // [v.3.1.1]
+      } else {
+        buffer[index] = (Byte)((MQTT_MSG_UNSUBSCRIBE_TYPE << MSG_TYPE_OFFSET) |
+                           (this.QosLevel << QOS_LEVEL_OFFSET));
+        buffer[index] |= this.DupFlag ? (Byte)(1 << DUP_FLAG_OFFSET) : (Byte)0x00;
+        index++;
+      }
+
+      // encode remaining length
+      index = this.EncodeRemainingLength(remainingLength, buffer, index);
+
+      // check message identifier assigned
+      if (this.MessageId == 0) {
+        throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
+      }
+
+      buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB
+      buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB 
+
+      for (topicIdx = 0; topicIdx < this.Topics.Length; topicIdx++) {
+        // topic name
+        buffer[index++] = (Byte)((topicsUtf8[topicIdx].Length >> 8) & 0x00FF); // MSB
+        buffer[index++] = (Byte)(topicsUtf8[topicIdx].Length & 0x00FF); // LSB
+        Array.Copy(topicsUtf8[topicIdx], 0, buffer, index, topicsUtf8[topicIdx].Length);
+        index += topicsUtf8[topicIdx].Length;
+      }
+
+      return buffer;
+    }
+
+    public override String ToString() =>
+#if TRACE
+      this.GetTraceString(
+          "UNSUBSCRIBE",
+          new Object[] { "messageId", "topics" },
+          new Object[] { this.MessageId, this.Topics });
+#else
+          base.ToString();
+#endif
+
+  }
 }

M2Mqtt/Messages/MqttMsgUnsubscribeEventArgs.cs

@@ -14,55 +14,41 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System;
 #else
 using Microsoft.SPOT;
 #endif
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Event Args class for unsubscribe request on topics
+  /// </summary>
+  public class MqttMsgUnsubscribeEventArgs : EventArgs {
+    #region Properties...
+
     /// <summary>
-    /// Event Args class for unsubscribe request on topics
+    /// Message identifier
     /// </summary>
-    public class MqttMsgUnsubscribeEventArgs : EventArgs
+    public UInt16 MessageId { get; internal set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    /// <summary>
-        /// Message identifier
+    /// Topics requested to subscribe
-        /// </summary>
+    /// </summary>
-        public ushort MessageId
+    public String[] Topics { get; internal set; }
-        {
-            get { return this.messageId; }
-            internal set { this.messageId = value; }
-        }
 
-        /// <summary>
+    #endregion
-        /// Topics requested to subscribe
-        /// </summary>
-        public string[] Topics
-        {
-            get { return this.topics; }
-            internal set { this.topics = value; }
-        }
 
-        #endregion
+    // message identifier
 
-        // message identifier
+    /// <summary>
-        ushort messageId;
+    /// Constructor
-        // topics requested to unsubscribe
+    /// </summary>
-        string[] topics;
+    /// <param name="messageId">Message identifier for subscribed topics</param>
-
+    /// <param name="topics">Topics requested to subscribe</param>
-        /// <summary>
+    public MqttMsgUnsubscribeEventArgs(UInt16 messageId, String[] topics) {
-        /// Constructor
+      this.MessageId = messageId;
-        /// </summary>
+      this.Topics = topics;
-        /// <param name="messageId">Message identifier for subscribed topics</param>
-        /// <param name="topics">Topics requested to subscribe</param>
-        public MqttMsgUnsubscribeEventArgs(ushort messageId, string[] topics)
-        {
-            this.messageId = messageId;
-            this.topics = topics;
-        }
     }
+  }
 }

M2Mqtt/Messages/MqttMsgUnsubscribedEventArgs.cs

@@ -14,42 +14,32 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
 using System;
 #else
 using Microsoft.SPOT;
 #endif
 
-namespace uPLibrary.Networking.M2Mqtt.Messages
+namespace uPLibrary.Networking.M2Mqtt.Messages {
-{
+  /// <summary>
+  /// Event Args class for unsubscribed topic
+  /// </summary>
+  public class MqttMsgUnsubscribedEventArgs : EventArgs {
+    #region Properties...
+
     /// <summary>
-    /// Event Args class for unsubscribed topic
+    /// Message identifier
     /// </summary>
-    public class MqttMsgUnsubscribedEventArgs : EventArgs
+    public UInt16 MessageId { get; internal set; }
-    {
-        #region Properties...
 
-        /// <summary>
+    #endregion
-        /// Message identifier
-        /// </summary>
-        public ushort MessageId
-        {
-            get { return this.messageId; }
-            internal set { this.messageId = value; }
-        }
 
-        #endregion
+    // message identifier
 
-        // message identifier
+    /// <summary>
-        ushort messageId;
+    /// Constructor
-
+    /// </summary>
-        /// <summary>
+    /// <param name="messageId">Message identifier for unsubscribed topic</param>
-        /// Constructor
+    public MqttMsgUnsubscribedEventArgs(UInt16 messageId) => this.MessageId = messageId;
-        /// </summary>
+  }
-        /// <param name="messageId">Message identifier for unsubscribed topic</param>
-        public MqttMsgUnsubscribedEventArgs(ushort messageId)
-        {
-            this.messageId = messageId;
-        }
-    }
 }

M2Mqtt/MqttSecurity.cs

@@ -14,17 +14,15 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-namespace uPLibrary.Networking.M2Mqtt
+namespace uPLibrary.Networking.M2Mqtt {
-{
+  /// <summary>
-    /// <summary>
+  /// Supported SSL/TLS protocol versions
-    /// Supported SSL/TLS protocol versions
+  /// </summary>
-    /// </summary>
+  public enum MqttSslProtocols {
-    public enum MqttSslProtocols
+    None,
-    {
+    SSLv3,
-        None,
+    TLSv1_0,
-        SSLv3,
+    TLSv1_1,
-        TLSv1_0,
+    TLSv1_2
-        TLSv1_1,
+  }
-        TLSv1_2
-    }
 }

M2Mqtt/MqttSettings.cs

@@ -14,91 +14,90 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-namespace uPLibrary.Networking.M2Mqtt
+using System;
-{
+
+namespace uPLibrary.Networking.M2Mqtt {
+  /// <summary>
+  /// Settings class for the MQTT broker
+  /// </summary>
+  public class MqttSettings {
+    // default port for MQTT protocol
+    public const Int32 MQTT_BROKER_DEFAULT_PORT = 1883;
+    public const Int32 MQTT_BROKER_DEFAULT_SSL_PORT = 8883;
+    // default timeout on receiving from client
+    public const Int32 MQTT_DEFAULT_TIMEOUT = 30000;
+    // max publish, subscribe and unsubscribe retry for QoS Level 1 or 2
+    public const Int32 MQTT_ATTEMPTS_RETRY = 3;
+    // delay for retry publish, subscribe and unsubscribe for QoS Level 1 or 2
+    public const Int32 MQTT_DELAY_RETRY = 10000;
+    // broker need to receive the first message (CONNECT)
+    // within a reasonable amount of time after TCP/IP connection 
+    public const Int32 MQTT_CONNECT_TIMEOUT = 30000;
+    // default inflight queue size
+    public const Int32 MQTT_MAX_INFLIGHT_QUEUE_SIZE = Int32.MaxValue;
+
     /// <summary>
-    /// Settings class for the MQTT broker
+    /// Listening connection port
     /// </summary>
-    public class MqttSettings
+    public Int32 Port { get; internal set; }
-    {
-        // default port for MQTT protocol
-        public const int MQTT_BROKER_DEFAULT_PORT = 1883;
-        public const int MQTT_BROKER_DEFAULT_SSL_PORT = 8883;
-        // default timeout on receiving from client
-        public const int MQTT_DEFAULT_TIMEOUT = 30000;
-        // max publish, subscribe and unsubscribe retry for QoS Level 1 or 2
-        public const int MQTT_ATTEMPTS_RETRY = 3;
-        // delay for retry publish, subscribe and unsubscribe for QoS Level 1 or 2
-        public const int MQTT_DELAY_RETRY = 10000;
-        // broker need to receive the first message (CONNECT)
-        // within a reasonable amount of time after TCP/IP connection 
-        public const int MQTT_CONNECT_TIMEOUT = 30000;
-        // default inflight queue size
-        public const int MQTT_MAX_INFLIGHT_QUEUE_SIZE = int.MaxValue;
 
-        /// <summary>
+    /// <summary>
-        /// Listening connection port
+    /// Listening connection SSL port
-        /// </summary>
+    /// </summary>
-        public int Port { get; internal set; }
+    public Int32 SslPort { get; internal set; }
 
-        /// <summary>
+    /// <summary>
-        /// Listening connection SSL port
+    /// Timeout on client connection (before receiving CONNECT message)
-        /// </summary>
+    /// </summary>
-        public int SslPort { get; internal set; }
+    public Int32 TimeoutOnConnection { get; internal set; }
 
-        /// <summary>
+    /// <summary>
-        /// Timeout on client connection (before receiving CONNECT message)
+    /// Timeout on receiving
-        /// </summary>
+    /// </summary>
-        public int TimeoutOnConnection { get; internal set; }
+    public Int32 TimeoutOnReceiving { get; internal set; }
 
-        /// <summary>
+    /// <summary>
-        /// Timeout on receiving
+    /// Attempts on retry
-        /// </summary>
+    /// </summary>
-        public int TimeoutOnReceiving { get; internal set; }
+    public Int32 AttemptsOnRetry { get; internal set; }
 
-        /// <summary>
+    /// <summary>
-        /// Attempts on retry
+    /// Delay on retry
-        /// </summary>
+    /// </summary>
-        public int AttemptsOnRetry { get; internal set; }
+    public Int32 DelayOnRetry { get; internal set; }
 
-        /// <summary>
+    /// <summary>
-        /// Delay on retry
+    /// Inflight queue size
-        /// </summary>
+    /// </summary>
-        public int DelayOnRetry { get; internal set; }
+    public Int32 InflightQueueSize { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// Inflight queue size
+    /// Singleton instance of settings
-        /// </summary>
+    /// </summary>
-        public int InflightQueueSize { get; set; }
+    public static MqttSettings Instance {
-        
+      get {
-        /// <summary>
+        if (instance == null) {
-        /// Singleton instance of settings
+          instance = new MqttSettings();
-        /// </summary>
-        public static MqttSettings Instance
-        {
-            get
-            {
-                if (instance == null)
-                    instance = new MqttSettings();
-                return instance;
-            }
         }
 
-        // singleton instance
+        return instance;
-        private static MqttSettings instance;
+      }
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        private MqttSettings()
-        {
-            this.Port = MQTT_BROKER_DEFAULT_PORT;
-            this.SslPort = MQTT_BROKER_DEFAULT_SSL_PORT;
-            this.TimeoutOnReceiving = MQTT_DEFAULT_TIMEOUT;
-            this.AttemptsOnRetry = MQTT_ATTEMPTS_RETRY;
-            this.DelayOnRetry = MQTT_DELAY_RETRY;
-            this.TimeoutOnConnection = MQTT_CONNECT_TIMEOUT;
-            this.InflightQueueSize = MQTT_MAX_INFLIGHT_QUEUE_SIZE;
-        }
     }
+
+    // singleton instance
+    private static MqttSettings instance;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    private MqttSettings() {
+      this.Port = MQTT_BROKER_DEFAULT_PORT;
+      this.SslPort = MQTT_BROKER_DEFAULT_SSL_PORT;
+      this.TimeoutOnReceiving = MQTT_DEFAULT_TIMEOUT;
+      this.AttemptsOnRetry = MQTT_ATTEMPTS_RETRY;
+      this.DelayOnRetry = MQTT_DELAY_RETRY;
+      this.TimeoutOnConnection = MQTT_CONNECT_TIMEOUT;
+      this.InflightQueueSize = MQTT_MAX_INFLIGHT_QUEUE_SIZE;
+    }
+  }
 }

M2Mqtt/Net/Fx.cs

@@ -14,23 +14,16 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using System.Threading;
 
-namespace uPLibrary.Networking.M2Mqtt
+namespace uPLibrary.Networking.M2Mqtt {
-{
+  /// <summary>
-    /// <summary>
+  /// Support methods fos specific framework
-    /// Support methods fos specific framework
+  /// </summary>
-    /// </summary>
+  public class Fx {
-    public class Fx
+    public static void StartThread(ThreadStart threadStart) => new Thread(threadStart).Start();
-    {
-        public static void StartThread(ThreadStart threadStart)
-        {
-            new Thread(threadStart).Start();
-        }
 
-        public static void SleepThread(int millisecondsTimeout)
+    public static void SleepThread(Int32 millisecondsTimeout) => Thread.Sleep(millisecondsTimeout);
-        {
+  }
-            Thread.Sleep(millisecondsTimeout);
-        }
-    }
 }

M2Mqtt/Net/MqttNetworkChannel.cs

@@ -15,13 +15,17 @@ Contributors:
 */
 
 #if SSL
-#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
 using Microsoft.SPOT.Net.Security;
 #else
-using System.Net.Security;
 using System.Security.Authentication;
+#if NETCOREAPP
+using System.Net.Security;
+#endif
+
 #endif
 #endif
+
 using System.Net.Sockets;
 using System.Net;
 using System.Security.Cryptography.X509Certificates;
@@ -29,90 +33,74 @@ using System;
 //using System.Security.Authentication;
 //using System.Net.Security;
 
-namespace uPLibrary.Networking.M2Mqtt
+namespace uPLibrary.Networking.M2Mqtt {
-{
+  /// <summary>
-    /// <summary>
+  /// Channel to communicate over the network
-    /// Channel to communicate over the network
+  /// </summary>
-    /// </summary>
+  public class MqttNetworkChannel : IMqttNetworkChannel {
-    public class MqttNetworkChannel : IMqttNetworkChannel
-    {
 #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
-        private readonly RemoteCertificateValidationCallback userCertificateValidationCallback;
+    private readonly RemoteCertificateValidationCallback userCertificateValidationCallback;
-        private readonly LocalCertificateSelectionCallback userCertificateSelectionCallback;
+    private readonly LocalCertificateSelectionCallback userCertificateSelectionCallback;
 #endif
-        // remote host information
+    // remote host information
-        private string remoteHostName;
-        private IPAddress remoteIpAddress;
-        private int remotePort;
 
-        // socket for communication
+    // socket for communication
-        private Socket socket;
+    private Socket socket;
-        // using SSL
+    // using SSL
-        private bool secure;
+    private readonly Boolean secure;
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
+    // CA certificate (on client)
+    private readonly X509Certificate caCert;
+#endif
+    // Server certificate (on broker)
+    private readonly X509Certificate serverCert;
+    // client certificate (on client)
+    private readonly X509Certificate clientCert;
 
-        // CA certificate (on client)
+    // SSL/TLS protocol version
-        private X509Certificate caCert;
+    private readonly MqttSslProtocols sslProtocol;
-        // Server certificate (on broker)
-        private X509Certificate serverCert;
-        // client certificate (on client)
-        private X509Certificate clientCert;
 
-        // SSL/TLS protocol version
+    /// <summary>
-        private MqttSslProtocols sslProtocol;
+    /// Remote host name
+    /// </summary>
+    public String RemoteHostName { get; }
 
-        /// <summary>
+    /// <summary>
-        /// Remote host name
+    /// Remote IP address
-        /// </summary>
+    /// </summary>
-        public string RemoteHostName { get { return this.remoteHostName; } }
+    public IPAddress RemoteIpAddress { get; }
 
-        /// <summary>
+    /// <summary>
-        /// Remote IP address
+    /// Remote port
-        /// </summary>
+    /// </summary>
-        public IPAddress RemoteIpAddress { get { return this.remoteIpAddress; } }
+    public Int32 RemotePort { get; }
-
-        /// <summary>
-        /// Remote port
-        /// </summary>
-        public int RemotePort { get { return this.remotePort; } }
 
 #if SSL
-        // SSL stream
+    // SSL stream
-        private SslStream sslStream;
+    private SslStream sslStream;
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
-        private NetworkStream netStream;
+    private NetworkStream netStream;
 #endif
 #endif
 
-        /// <summary>
+    /// <summary>
-        /// Data available on the channel
+    /// Data available on the channel
-        /// </summary>
+    /// </summary>
-        public bool DataAvailable
-        {
-            get
-            {
 #if SSL
-#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
-                if (secure)
+    public Boolean DataAvailable => this.secure ? this.sslStream.DataAvailable : this.socket.Available > 0;
-                    return this.sslStream.DataAvailable;
-                else
-                    return (this.socket.Available > 0);
 #else
-                if (secure)
+    public Boolean DataAvailable => this.secure ? this.netStream.DataAvailable : this.socket.Available > 0;
-                    return this.netStream.DataAvailable;
-                else
-                    return (this.socket.Available > 0);
 #endif
 #else
-                return (this.socket.Available > 0);
+    public Boolean DataAvailable => this.socket.Available > 0;
 #endif
-            }
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Constructor
-        /// </summary>
+    /// </summary>
-        /// <param name="socket">Socket opened with the client</param>
+    /// <param name="socket">Socket opened with the client</param>
-        public MqttNetworkChannel(Socket socket)
+    public MqttNetworkChannel(Socket socket)
 #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
             : this(socket, false, null, MqttSslProtocols.None, null, null)
 #else
@@ -120,212 +108,205 @@ namespace uPLibrary.Networking.M2Mqtt
 #endif
         {
 
-        }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Constructor
-        /// </summary>
+    /// </summary>
-        /// <param name="socket">Socket opened with the client</param>
+    /// <param name="socket">Socket opened with the client</param>
-        /// <param name="secure">Secure connection (SSL/TLS)</param>
+    /// <param name="secure">Secure connection (SSL/TLS)</param>
-        /// <param name="serverCert">Server X509 certificate for secure connection</param>
+    /// <param name="serverCert">Server X509 certificate for secure connection</param>
-        /// <param name="sslProtocol">SSL/TLS protocol version</param>
+    /// <param name="sslProtocol">SSL/TLS protocol version</param>
 #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
-        /// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param>
+    /// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param>
-        /// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param>
+    /// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param>
-        public MqttNetworkChannel(Socket socket, bool secure, X509Certificate serverCert, MqttSslProtocols sslProtocol,
+    public MqttNetworkChannel(Socket socket, Boolean secure, X509Certificate serverCert, MqttSslProtocols sslProtocol,
-            RemoteCertificateValidationCallback userCertificateValidationCallback,
+        RemoteCertificateValidationCallback userCertificateValidationCallback,
-            LocalCertificateSelectionCallback userCertificateSelectionCallback)
+        LocalCertificateSelectionCallback userCertificateSelectionCallback)
 #else
         public MqttNetworkChannel(Socket socket, bool secure, X509Certificate serverCert, MqttSslProtocols sslProtocol)
 #endif
         {
-            this.socket = socket;
+      this.socket = socket;
-            this.secure = secure;
+      this.secure = secure;
-            this.serverCert = serverCert;
+      this.serverCert = serverCert;
-            this.sslProtocol = sslProtocol;
+      this.sslProtocol = sslProtocol;
 #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
-            this.userCertificateValidationCallback = userCertificateValidationCallback;
+      this.userCertificateValidationCallback = userCertificateValidationCallback;
-            this.userCertificateSelectionCallback = userCertificateSelectionCallback;
+      this.userCertificateSelectionCallback = userCertificateSelectionCallback;
 #endif
-        }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Constructor
-        /// </summary>
+    /// </summary>
-        /// <param name="remoteHostName">Remote Host name</param>
+    /// <param name="remoteHostName">Remote Host name</param>
-        /// <param name="remotePort">Remote port</param>
+    /// <param name="remotePort">Remote port</param>
-        public MqttNetworkChannel(string remoteHostName, int remotePort)
+    public MqttNetworkChannel(String remoteHostName, Int32 remotePort)
 #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
             : this(remoteHostName, remotePort, false, null, null, MqttSslProtocols.None, null, null)
 #else
             : this(remoteHostName, remotePort, false, null, null, MqttSslProtocols.None)
 #endif
         {
-        }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Constructor
-        /// </summary>
+    /// </summary>
-        /// <param name="remoteHostName">Remote Host name</param>
+    /// <param name="remoteHostName">Remote Host name</param>
-        /// <param name="remotePort">Remote port</param>
+    /// <param name="remotePort">Remote port</param>
-        /// <param name="secure">Using SSL</param>
+    /// <param name="secure">Using SSL</param>
-        /// <param name="caCert">CA certificate</param>
+    /// <param name="caCert">CA certificate</param>
-        /// <param name="clientCert">Client certificate</param>
+    /// <param name="clientCert">Client certificate</param>
-        /// <param name="sslProtocol">SSL/TLS protocol version</param>
+    /// <param name="sslProtocol">SSL/TLS protocol version</param>
 #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
-        /// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param>
+    /// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param>
-        /// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param>
+    /// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param>
-        public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol,
+    public MqttNetworkChannel(String remoteHostName, Int32 remotePort, Boolean secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol,
-            RemoteCertificateValidationCallback userCertificateValidationCallback,
+        RemoteCertificateValidationCallback userCertificateValidationCallback,
-            LocalCertificateSelectionCallback userCertificateSelectionCallback)
+        LocalCertificateSelectionCallback userCertificateSelectionCallback)
 #else
         public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol)
 #endif
         {
-            IPAddress remoteIpAddress = null;
+      IPAddress remoteIpAddress = null;
-            try
+      try {
-            {
+        // check if remoteHostName is a valid IP address and get it
-                // check if remoteHostName is a valid IP address and get it
+        remoteIpAddress = IPAddress.Parse(remoteHostName);
-                remoteIpAddress = IPAddress.Parse(remoteHostName);
+      } catch {
-            }
+      }
-            catch
-            {
-            }
 
-            // in this case the parameter remoteHostName isn't a valid IP address
+      // in this case the parameter remoteHostName isn't a valid IP address
-            if (remoteIpAddress == null)
+      if (remoteIpAddress == null) {
-            {
+        IPHostEntry hostEntry = Dns.GetHostEntry(remoteHostName);
-                IPHostEntry hostEntry = Dns.GetHostEntry(remoteHostName);
+        if (hostEntry != null && hostEntry.AddressList.Length > 0) {
-                if ((hostEntry != null) && (hostEntry.AddressList.Length > 0))
+          // check for the first address not null
-                {
+          // it seems that with .Net Micro Framework, the IPV6 addresses aren't supported and return "null"
-                    // check for the first address not null
+          Int32 i = 0;
-                    // it seems that with .Net Micro Framework, the IPV6 addresses aren't supported and return "null"
+          while (hostEntry.AddressList[i] == null) {
-                    int i = 0;
+            i++;
-                    while (hostEntry.AddressList[i] == null) i++;
+          }
-                    remoteIpAddress = hostEntry.AddressList[i];
-                }
-                else
-                {
-                    throw new Exception("No address found for the remote host name");
-                }
-            }
 
-            this.remoteHostName = remoteHostName;
+          remoteIpAddress = hostEntry.AddressList[i];
-            this.remoteIpAddress = remoteIpAddress;
+        } else {
-            this.remotePort = remotePort;
+          throw new Exception("No address found for the remote host name");
-            this.secure = secure;
-            this.caCert = caCert;
-            this.clientCert = clientCert;
-            this.sslProtocol = sslProtocol;
-#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
-            this.userCertificateValidationCallback = userCertificateValidationCallback;
-            this.userCertificateSelectionCallback = userCertificateSelectionCallback;
-#endif
         }
+      }
 
-        /// <summary>
+      this.RemoteHostName = remoteHostName;
-        /// Connect to remote server
+      this.RemoteIpAddress = remoteIpAddress;
-        /// </summary>
+      this.RemotePort = remotePort;
-        public void Connect()
+      this.secure = secure;
-        {
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
-            this.socket = new Socket(IPAddressUtility.GetAddressFamily(this.remoteIpAddress), SocketType.Stream, ProtocolType.Tcp);
+      this.caCert = caCert;
-            // try connection to the broker
+#endif
-            this.socket.Connect(new IPEndPoint(this.remoteIpAddress, this.remotePort));
+      this.clientCert = clientCert;
+      this.sslProtocol = sslProtocol;
+#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
+      this.userCertificateValidationCallback = userCertificateValidationCallback;
+      this.userCertificateSelectionCallback = userCertificateSelectionCallback;
+#endif
+    }
+
+    /// <summary>
+    /// Connect to remote server
+    /// </summary>
+    public void Connect() {
+      this.socket = new Socket(IPAddressUtility.GetAddressFamily(this.RemoteIpAddress), SocketType.Stream, ProtocolType.Tcp);
+      // try connection to the broker
+      this.socket.Connect(new IPEndPoint(this.RemoteIpAddress, this.RemotePort));
 
 #if SSL
-            // secure channel requested
+      // secure channel requested
-            if (secure)
+      if (this.secure) {
-            {
+        // create SSL stream
-                // create SSL stream
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
-#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
                 this.sslStream = new SslStream(this.socket);
 #else
-                this.netStream = new NetworkStream(this.socket);
+        this.netStream = new NetworkStream(this.socket);
-                this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback);
+        this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback);
 #endif
 
-                // server authentication (SSL/TLS handshake)
+        // server authentication (SSL/TLS handshake)
-#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
+#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
                 this.sslStream.AuthenticateAsClient(this.remoteHostName,
                     this.clientCert,
                     new X509Certificate[] { this.caCert },
                     SslVerification.CertificateRequired,
                     MqttSslUtility.ToSslPlatformEnum(this.sslProtocol));
 #else
-                X509CertificateCollection clientCertificates = null;
+        X509CertificateCollection clientCertificates = null;
-                // check if there is a client certificate to add to the collection, otherwise it's null (as empty)
+        // check if there is a client certificate to add to the collection, otherwise it's null (as empty)
-                if (this.clientCert != null)
+        if (this.clientCert != null) {
-                    clientCertificates = new X509CertificateCollection(new X509Certificate[] { this.clientCert });
+          clientCertificates = new X509CertificateCollection(new X509Certificate[] { this.clientCert });
-
-                this.sslStream.AuthenticateAsClient(this.remoteHostName,
-                    clientCertificates,
-                    MqttSslUtility.ToSslPlatformEnum(this.sslProtocol),
-                    false);
-                
-#endif
-            }
-#endif
         }
 
-        /// <summary>
+        this.sslStream.AuthenticateAsClient(this.RemoteHostName,
-        /// Send data on the network channel
+            clientCertificates,
-        /// </summary>
+            MqttSslUtility.ToSslPlatformEnum(this.sslProtocol),
-        /// <param name="buffer">Data buffer to send</param>
+            false);
-        /// <returns>Number of byte sent</returns>
+
-        public int Send(byte[] buffer)
+#endif
-        {
+      }
+#endif
+    }
+
+    /// <summary>
+    /// Send data on the network channel
+    /// </summary>
+    /// <param name="buffer">Data buffer to send</param>
+    /// <returns>Number of byte sent</returns>
+    public Int32 Send(Byte[] buffer) {
 #if SSL
-            if (this.secure)
+      if (this.secure) {
-            {
+        this.sslStream.Write(buffer, 0, buffer.Length);
-                this.sslStream.Write(buffer, 0, buffer.Length);
+        this.sslStream.Flush();
-                this.sslStream.Flush();
+        return buffer.Length;
-                return buffer.Length;
+      } else {
-            }
+        return this.socket.Send(buffer, 0, buffer.Length, SocketFlags.None);
-            else
+      }
-                return this.socket.Send(buffer, 0, buffer.Length, SocketFlags.None);
 #else
             return this.socket.Send(buffer, 0, buffer.Length, SocketFlags.None);
 #endif
-        }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Receive data from the network
+    /// Receive data from the network
-        /// </summary>
+    /// </summary>
-        /// <param name="buffer">Data buffer for receiving data</param>
+    /// <param name="buffer">Data buffer for receiving data</param>
-        /// <returns>Number of bytes received</returns>
+    /// <returns>Number of bytes received</returns>
-        public int Receive(byte[] buffer)
+    public Int32 Receive(Byte[] buffer) {
-        {
 #if SSL
-            if (this.secure)
+      if (this.secure) {
-            {
+        // read all data needed (until fill buffer)
-                // read all data needed (until fill buffer)
+        Int32 idx = 0, read = 0;
-                int idx = 0, read = 0;
+        while (idx < buffer.Length) {
-                while (idx < buffer.Length)
+          // fixed scenario with socket closed gracefully by peer/broker and
-                {
+          // Read return 0. Avoid infinite loop.
-                    // fixed scenario with socket closed gracefully by peer/broker and
+          read = this.sslStream.Read(buffer, idx, buffer.Length - idx);
-                    // Read return 0. Avoid infinite loop.
+          if (read == 0) {
-                    read = this.sslStream.Read(buffer, idx, buffer.Length - idx);
+            return 0;
-                    if (read == 0)
+          }
-                        return 0;
+
-                    idx += read;
+          idx += read;
-                }
+        }
-                return buffer.Length;
+        return buffer.Length;
-            }
+      } else {
-            else
+        // read all data needed (until fill buffer)
-            {
+        Int32 idx = 0, read = 0;
-                // read all data needed (until fill buffer)
+        while (idx < buffer.Length) {
-                int idx = 0, read = 0;
+          // fixed scenario with socket closed gracefully by peer/broker and
-                while (idx < buffer.Length)
+          // Read return 0. Avoid infinite loop.
-                {
+          read = this.socket.Receive(buffer, idx, buffer.Length - idx, SocketFlags.None);
-                    // fixed scenario with socket closed gracefully by peer/broker and
+          if (read == 0) {
-                    // Read return 0. Avoid infinite loop.
+            return 0;
-                    read = this.socket.Receive(buffer, idx, buffer.Length - idx, SocketFlags.None);
+          }
-                    if (read == 0)
+
-                        return 0;
+          idx += read;
-                    idx += read;
+        }
-                }
+        return buffer.Length;
-                return buffer.Length;
+      }
-            }
 #else
             // read all data needed (until fill buffer)
             int idx = 0, read = 0;
@@ -340,118 +321,94 @@ namespace uPLibrary.Networking.M2Mqtt
             }
             return buffer.Length;
 #endif
-        }
-
-        /// <summary>
-        /// Receive data from the network channel with a specified timeout
-        /// </summary>
-        /// <param name="buffer">Data buffer for receiving data</param>
-        /// <param name="timeout">Timeout on receiving (in milliseconds)</param>
-        /// <returns>Number of bytes received</returns>
-        public int Receive(byte[] buffer, int timeout)
-        {
-            // check data availability (timeout is in microseconds)
-            if (this.socket.Poll(timeout * 1000, SelectMode.SelectRead))
-            {
-                return this.Receive(buffer);
-            }
-            else
-            {
-                return 0;
-            }
-        }
-
-        /// <summary>
-        /// Close the network channel
-        /// </summary>
-        public void Close()
-        {
-#if SSL
-            if (this.secure)
-            {
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
-                this.netStream.Close();
-#endif
-                this.sslStream.Close();
-            }
-            this.socket.Close();
-#else
-            this.socket.Close();
-#endif
-        }
-
-        /// <summary>
-        /// Accept connection from a remote client
-        /// </summary>
-        public void Accept()
-        {
-#if SSL
-            // secure channel requested
-            if (secure)
-            {
-#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
-
-                this.netStream = new NetworkStream(this.socket);
-                this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback);
-
-                this.sslStream.AuthenticateAsServer(this.serverCert, false, MqttSslUtility.ToSslPlatformEnum(this.sslProtocol), false);
-#endif
-            }
-
-            return;
-#else
-            return;
-#endif
-        }
     }
 
     /// <summary>
-    /// IPAddress Utility class
+    /// Receive data from the network channel with a specified timeout
     /// </summary>
-    public static class IPAddressUtility
+    /// <param name="buffer">Data buffer for receiving data</param>
-    {
+    /// <param name="timeout">Timeout on receiving (in milliseconds)</param>
-        /// <summary>
+    /// <returns>Number of bytes received</returns>
-        /// Return AddressFamily for the IP address
+    public Int32 Receive(Byte[] buffer, Int32 timeout) =>
-        /// </summary>
+      // check data availability (timeout is in microseconds)
-        /// <param name="ipAddress">IP address to check</param>
+      this.socket.Poll(timeout * 1000, SelectMode.SelectRead) ? this.Receive(buffer) : 0;
-        /// <returns>Address family</returns>
+
-        public static AddressFamily GetAddressFamily(IPAddress ipAddress)
+    /// <summary>
-        {
+    /// Close the network channel
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+    /// </summary>
-            return ipAddress.AddressFamily;
+    public void Close() {
+#if SSL
+      if (this.secure) {
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
+        this.netStream.Close();
+#endif
+        this.sslStream.Close();
+      }
+      this.socket.Close();
+#else
+            this.socket.Close();
+#endif
+    }
+
+    /// <summary>
+    /// Accept connection from a remote client
+    /// </summary>
+    public void Accept() {
+#if SSL
+      // secure channel requested
+      if (this.secure) {
+#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
+
+        this.netStream = new NetworkStream(this.socket);
+        this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback);
+
+        this.sslStream.AuthenticateAsServer(this.serverCert, false, MqttSslUtility.ToSslPlatformEnum(this.sslProtocol), false);
+#endif
+      }
+
+      return;
+#else
+            return;
+#endif
+    }
+  }
+
+  /// <summary>
+  /// IPAddress Utility class
+  /// </summary>
+  public static class IPAddressUtility {
+    /// <summary>
+    /// Return AddressFamily for the IP address
+    /// </summary>
+    /// <param name="ipAddress">IP address to check</param>
+    /// <returns>Address family</returns>
+    public static AddressFamily GetAddressFamily(IPAddress ipAddress) =>
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3
+      ipAddress.AddressFamily;
 #else
             return (ipAddress.ToString().IndexOf(':') != -1) ? 
                 AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork;
 #endif
-        }
-    }
 
-    /// <summary>
+  }
-    /// MQTT SSL utility class
+
-    /// </summary>
+  /// <summary>
-    public static class MqttSslUtility
+  /// MQTT SSL utility class
+  /// </summary>
+  public static class MqttSslUtility {
+#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 && !COMPACT_FRAMEWORK
+    
+    public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol) => mqttSslProtocol switch
     {
-#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 && !COMPACT_FRAMEWORK)
+      MqttSslProtocols.None => SslProtocols.None,
-        public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
+      //MqttSslProtocols.SSLv3 => SslProtocols.Ssl3,
-        {
+      MqttSslProtocols.TLSv1_0 => SslProtocols.Tls,
-            switch (mqttSslProtocol)
+      MqttSslProtocols.TLSv1_1 => SslProtocols.Tls11,
-            {
+      MqttSslProtocols.TLSv1_2 => SslProtocols.Tls12,
-                case MqttSslProtocols.None:
+      _ => throw new ArgumentException("SSL/TLS protocol version not supported"),
-                    return SslProtocols.None;
+    };
-                case MqttSslProtocols.SSLv3:
+#elif MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
-                    return SslProtocols.Ssl3;
+    public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
-                case MqttSslProtocols.TLSv1_0:
-                    return SslProtocols.Tls;
-                /*case MqttSslProtocols.TLSv1_1:
-                    return SslProtocols.Tls11;
-                case MqttSslProtocols.TLSv1_2:
-                    return SslProtocols.Tls12;*/
-                default:
-                    throw new ArgumentException("SSL/TLS protocol version not supported");
-            }
-        }
-#elif (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
-        public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
         {
             switch (mqttSslProtocol)
             {
@@ -468,5 +425,5 @@ namespace uPLibrary.Networking.M2Mqtt
             }
         }
 #endif
-    }
+  }
 }

M2Mqtt/Properties/AssemblyInfo.cs

@@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
 Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
-
+#if !NETCOREAPP
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -42,3 +42,4 @@ using System.Runtime.InteropServices;
 #if !WindowsCE
 [assembly: AssemblyFileVersion("4.3.0.0")]
 #endif
+#endif

M2Mqtt/Session/MqttClientSession.cs

@@ -14,20 +14,18 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
-namespace uPLibrary.Networking.M2Mqtt.Session
+using System;
-{
+
+namespace uPLibrary.Networking.M2Mqtt.Session {
+  /// <summary>
+  /// MQTT Client Session
+  /// </summary>
+  public class MqttClientSession : MqttSession {
     /// <summary>
-    /// MQTT Client Session
+    /// Constructor
     /// </summary>
-    public class MqttClientSession : MqttSession
+    /// <param name="clientId">Client Id to create session</param>
-    {
+    public MqttClientSession(String clientId) : base(clientId) {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="clientId">Client Id to create session</param>
-        public MqttClientSession(string clientId)
-            : base(clientId)
-        {
-        }
     }
+  }
 }

M2Mqtt/Session/MqttSession.cs

@@ -14,50 +14,46 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using System.Collections;
 
-namespace uPLibrary.Networking.M2Mqtt.Session
+namespace uPLibrary.Networking.M2Mqtt.Session {
-{
+  /// <summary>
+  /// MQTT Session base class
+  /// </summary>
+  public abstract class MqttSession {
     /// <summary>
-    /// MQTT Session base class
+    /// Client Id
     /// </summary>
-    public abstract class MqttSession
+    public String ClientId { get; set; }
-    {
-        /// <summary>
-        /// Client Id
-        /// </summary>
-        public string ClientId { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// Messages inflight during session
+    /// Messages inflight during session
-        /// </summary>
+    /// </summary>
-        public Hashtable InflightMessages { get; set; }
+    public Hashtable InflightMessages { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// Constructor
+    /// Constructor
-        /// </summary>
+    /// </summary>
-        public MqttSession()
+    public MqttSession()
-            : this(null)
+        : this(null) {
-        {
-        }
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="clientId">Client Id to create session</param>
-        public MqttSession(string clientId)
-        {
-            this.ClientId = clientId;
-            this.InflightMessages = new Hashtable();
-        }
-
-        /// <summary>
-        /// Clean session
-        /// </summary>
-        public virtual void Clear()
-        {
-            this.ClientId = null;
-            this.InflightMessages.Clear();
-        }
     }
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="clientId">Client Id to create session</param>
+    public MqttSession(String clientId) {
+      this.ClientId = clientId;
+      this.InflightMessages = new Hashtable();
+    }
+
+    /// <summary>
+    /// Clean session
+    /// </summary>
+    public virtual void Clear() {
+      this.ClientId = null;
+      this.InflightMessages.Clear();
+    }
+  }
 }

M2Mqtt/Utility/QueueExtension.cs

@@ -17,34 +17,31 @@ Contributors:
 using System;
 using System.Collections;
 
-namespace uPLibrary.Networking.M2Mqtt.Utility
+namespace uPLibrary.Networking.M2Mqtt.Utility {
-{
+  /// <summary>
+  /// Extension class for a Queue
+  /// </summary>
+  internal static class QueueExtension {
     /// <summary>
-    /// Extension class for a Queue
+    /// Predicate for searching inside a queue
     /// </summary>
-    internal static class QueueExtension
+    /// <param name="item">Item of the queue</param>
-    {
+    /// <returns>Result of predicate</returns>
-        /// <summary>
+    internal delegate Boolean QueuePredicate(Object item);
-        /// Predicate for searching inside a queue
-        /// </summary>
-        /// <param name="item">Item of the queue</param>
-        /// <returns>Result of predicate</returns>
-        internal delegate bool QueuePredicate(object item);
 
-        /// <summary>
+    /// <summary>
-        /// Get (without removing) an item from queue based on predicate
+    /// Get (without removing) an item from queue based on predicate
-        /// </summary>
+    /// </summary>
-        /// <param name="queue">Queue in which to search</param>
+    /// <param name="queue">Queue in which to search</param>
-        /// <param name="predicate">Predicate to verify to get item</param>
+    /// <param name="predicate">Predicate to verify to get item</param>
-        /// <returns>Item matches the predicate</returns>
+    /// <returns>Item matches the predicate</returns>
-        internal static object Get(Queue queue, QueuePredicate predicate)
+    internal static Object Get(Queue queue, QueuePredicate predicate) {
-        {
+      foreach (Object item in queue) {
-            foreach (var item in queue)
+        if (predicate(item)) {
-            {
+          return item;
-                if (predicate(item))
-                    return item;
-            }
-            return null;
         }
+      }
+      return null;
     }
+  }
 }

M2Mqtt/Utility/Trace.cs

@@ -14,73 +14,57 @@ Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
 
+using System;
 using System.Diagnostics;
 
-namespace uPLibrary.Networking.M2Mqtt.Utility
+namespace uPLibrary.Networking.M2Mqtt.Utility {
-{
+  /// <summary>
-    /// <summary>
+  /// Tracing levels
-    /// Tracing levels
+  /// </summary>
-    /// </summary>
+  public enum TraceLevel {
-    public enum TraceLevel
+    Error = 0x01,
-    {
+    Warning = 0x02,
-        Error = 0x01,
+    Information = 0x04,
-        Warning = 0x02,
+    Verbose = 0x0F,
-        Information = 0x04,
+    Frame = 0x10,
-        Verbose = 0x0F,
+    Queuing = 0x20
-        Frame = 0x10,
+  }
-        Queuing = 0x20
+
+  // delegate for writing trace
+  public delegate void WriteTrace(String format, params Object[] args);
+
+  /// <summary>
+  /// Tracing class
+  /// </summary>
+  public static class Trace {
+    public static TraceLevel TraceLevel;
+    public static WriteTrace TraceListener;
+
+    [Conditional("DEBUG")]
+    public static void Debug(String format, params Object[] args) => TraceListener?.Invoke(format, args);
+
+    public static void WriteLine(TraceLevel level, String format) {
+      if ((level & TraceLevel) > 0) {
+        TraceListener.Invoke(format);
+      }
     }
 
-    // delegate for writing trace
+    public static void WriteLine(TraceLevel level, String format, Object arg1) {
-    public delegate void WriteTrace(string format, params object[] args);
+      if ( (level & TraceLevel) > 0) {
-
+        TraceListener.Invoke(format, arg1);
-    /// <summary>
+      }
-    /// Tracing class
-    /// </summary>
-    public static class Trace
-    {
-        public static TraceLevel TraceLevel;
-        public static WriteTrace TraceListener;
-
-        [Conditional("DEBUG")]
-        public static void Debug(string format, params object[] args)
-        {
-            if (TraceListener != null)
-            {
-                TraceListener(format, args);
-            }
-        }
-
-        public static void WriteLine(TraceLevel level, string format)
-        {
-            if (TraceListener != null && (level & TraceLevel) > 0)
-            {
-                TraceListener(format);
-            }
-        }
-
-        public static void WriteLine(TraceLevel level, string format, object arg1)
-        {
-            if (TraceListener != null && (level & TraceLevel) > 0)
-            {
-                TraceListener(format, arg1);
-            }
-        }
-
-        public static void WriteLine(TraceLevel level, string format, object arg1, object arg2)
-        {
-            if (TraceListener != null && (level & TraceLevel) > 0)
-            {
-                TraceListener(format, arg1, arg2);
-            }
-        }
-
-        public static void WriteLine(TraceLevel level, string format, object arg1, object arg2, object arg3)
-        {
-            if (TraceListener != null && (level & TraceLevel) > 0)
-            {
-                TraceListener(format, arg1, arg2, arg3);
-            }
-        }
     }
+
+    public static void WriteLine(TraceLevel level, String format, Object arg1, Object arg2) {
+      if ((level & TraceLevel) > 0) {
+        TraceListener.Invoke(format, arg1, arg2);
+      }
+    }
+
+    public static void WriteLine(TraceLevel level, String format, Object arg1, Object arg2, Object arg3) {
+      if ((level & TraceLevel) > 0) {
+        TraceListener.Invoke(format, arg1, arg2, arg3);
+      }
+    }
+  }
 }

M2Mqtt/WinRT/Fx.cs

@@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
 Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
-
+#if !NETCOREAPP
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -34,3 +34,4 @@ namespace uPLibrary.Networking.M2Mqtt
         public static void SleepThread(int millisecondsTimeout) { Task.Delay(millisecondsTimeout).RunSynchronously(); }
     }
 }
+#endif

M2Mqtt/WinRT/Hashtable.cs

@@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
 Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
-
+#if !NETCOREAPP
 using System.Collections.Generic;
 
 namespace uPLibrary.Networking.M2Mqtt
@@ -25,3 +25,4 @@ namespace uPLibrary.Networking.M2Mqtt
     {
     }
 }
+#endif

M2Mqtt/WinRT/MqttNetworkChannel.cs

@@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
 Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
-
+#if !NETCOREAPP
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -177,3 +177,4 @@ namespace uPLibrary.Networking.M2Mqtt
         }
     }
 }
+#endif

M2Mqtt/WinRT/Queue.cs

@@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
 Contributors:
    Paolo Patierno - initial API and implementation and/or initial documentation
 */
-
+#if !NETCOREAPP
 using System.Collections.Generic;
 
 namespace uPLibrary.Networking.M2Mqtt
@@ -25,3 +25,4 @@ namespace uPLibrary.Networking.M2Mqtt
     {
     }
 }
+#endif

README.md

@@ -0,0 +1,4 @@
+# M2Mqtt
+Based on https://github.com/eclipse/paho.mqtt.m2mqtt
+
+Maybe you find this Repo on Github. This is a mirror from [here](https://git.blubbfish.net/vs_librarys/mqtt).