Accept multiple SubscriptionIdentifiers for PUBLISH packets.

chkr1011 · chkr1011 · commit c22b6033e3eb · 2019-05-12T17:26:36.000+02:00
diff --git a/Source/MQTTnet/Formatter/V5/MqttV500DataConverter.cs b/Source/MQTTnet/Formatter/V5/MqttV500DataConverter.cs
@@ -33,13 +33,14 @@ public MqttPublishPacket CreatePublishPacket(MqttApplicationMessage applicationM
                     MessageExpiryInterval = applicationMessage.MessageExpiryInterval,
                     PayloadFormatIndicator = applicationMessage.PayloadFormatIndicator,
                     ResponseTopic = applicationMessage.ResponseTopic,
-                    SubscriptionIdentifier = applicationMessage.SubscriptionIdentifier,
+                    SubscriptionIdentifiers = applicationMessage.SubscriptionIdentifiers,
                     TopicAlias = applicationMessage.TopicAlias
                 }
             };
 
             if (applicationMessage.UserProperties != null)
             {
+                packet.Properties.UserProperties = new List<MqttUserProperty>();
                 packet.Properties.UserProperties.AddRange(applicationMessage.UserProperties);
             }
 
@@ -67,7 +68,7 @@ public MqttApplicationMessage CreateApplicationMessage(MqttPublishPacket publish
                 ContentType = publishPacket.Properties?.ContentType,
                 CorrelationData = publishPacket.Properties?.CorrelationData,
                 MessageExpiryInterval = publishPacket.Properties?.MessageExpiryInterval,
-                SubscriptionIdentifier = publishPacket.Properties?.SubscriptionIdentifier,
+                SubscriptionIdentifiers = publishPacket.Properties?.SubscriptionIdentifiers,
                 TopicAlias = publishPacket.Properties?.TopicAlias,
                 PayloadFormatIndicator = publishPacket.Properties?.PayloadFormatIndicator,
                 UserProperties = publishPacket.Properties?.UserProperties ?? new List<MqttUserProperty>()
diff --git a/Source/MQTTnet/Formatter/V5/MqttV500PacketDecoder.cs b/Source/MQTTnet/Formatter/V5/MqttV500PacketDecoder.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.Linq;
 using MQTTnet.Adapter;
 using MQTTnet.Exceptions;
@@ -117,7 +118,7 @@ private static MqttBasePacket DecodeConnectPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -155,7 +156,12 @@ private static MqttBasePacket DecodeConnectPacket(IMqttPacketBodyReader body)
                     }
                     else if (willPropertiesReader.CurrentPropertyId == MqttPropertyId.SubscriptionIdentifier)
                     {
-                        packet.WillMessage.SubscriptionIdentifier = propertiesReader.ReadSubscriptionIdentifier();
+                        if (packet.WillMessage.SubscriptionIdentifiers == null)
+                        {
+                            packet.WillMessage.SubscriptionIdentifiers = new List<uint>();
+                        }
+
+                        packet.WillMessage.SubscriptionIdentifiers.Add(propertiesReader.ReadSubscriptionIdentifier());
                     }
                     else if (willPropertiesReader.CurrentPropertyId == MqttPropertyId.ContentType)
                     {
@@ -168,7 +174,12 @@ private static MqttBasePacket DecodeConnectPacket(IMqttPacketBodyReader body)
                     }
                     else if (willPropertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                     {
-                        propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                        if (packet.WillMessage.UserProperties == null)
+                        {
+                            packet.WillMessage.UserProperties = new List<MqttUserProperty>();
+                        }
+
+                        propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                     }
                     else
                     {
@@ -271,7 +282,7 @@ private static MqttBasePacket DecodeConnAckPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -309,7 +320,7 @@ private static MqttBasePacket DecodeDisconnectPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -339,7 +350,7 @@ private static MqttBasePacket DecodeSubscribePacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -389,7 +400,7 @@ private static MqttBasePacket DecodeSubAckPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -421,7 +432,7 @@ private static MqttBasePacket DecodeUnsubscribePacket(IMqttPacketBodyReader body
             {
                 if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -456,7 +467,7 @@ private static MqttBasePacket DecodeUnsubAckPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -530,15 +541,25 @@ private static MqttBasePacket DecodePublishPacket(byte header, IMqttPacketBodyRe
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.SubscriptionIdentifier)
                 {
-                    packet.Properties.SubscriptionIdentifier = propertiesReader.ReadSubscriptionIdentifier();
+                    if (packet.Properties.SubscriptionIdentifiers == null)
+                    {
+                        packet.Properties.SubscriptionIdentifiers = new List<uint>();
+                    }
+
+                    packet.Properties.SubscriptionIdentifiers.Add(propertiesReader.ReadSubscriptionIdentifier());
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.ContentType)
                 {
                     packet.Properties.ContentType = propertiesReader.ReadContentType();
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    if (packet.Properties.UserProperties == null)
+                    {
+                        packet.Properties.UserProperties = new List<MqttUserProperty>();
+                    }
+
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -581,7 +602,7 @@ private static MqttBasePacket DecodePubAckPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -619,7 +640,7 @@ private static MqttBasePacket DecodePubRecPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -657,7 +678,7 @@ private static MqttBasePacket DecodePubRelPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -695,7 +716,7 @@ private static MqttBasePacket DecodePubCompPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
@@ -740,7 +761,7 @@ private static MqttBasePacket DecodeAuthPacket(IMqttPacketBodyReader body)
                 }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)
                 {
-                    propertiesReader.FillUserProperties(packet.Properties.UserProperties);
+                    propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);
                 }
                 else
                 {
diff --git a/Source/MQTTnet/Formatter/V5/MqttV500PacketEncoder.cs b/Source/MQTTnet/Formatter/V5/MqttV500PacketEncoder.cs
@@ -150,7 +150,7 @@ private static byte EncodeConnectPacket(MqttConnectPacket packet, IMqttPacketWri
                 willPropertiesWriter.WriteTopicAlias(packet.WillMessage.TopicAlias);
                 willPropertiesWriter.WriteResponseTopic(packet.WillMessage.ResponseTopic);
                 willPropertiesWriter.WriteCorrelationData(packet.WillMessage.CorrelationData);
-                willPropertiesWriter.WriteSubscriptionIdentifier(packet.WillMessage.SubscriptionIdentifier);
+                willPropertiesWriter.WriteSubscriptionIdentifiers(packet.WillMessage.SubscriptionIdentifiers);
                 willPropertiesWriter.WriteContentType(packet.WillMessage.ContentType);
                 willPropertiesWriter.WriteUserProperties(packet.WillMessage.UserProperties);
                 
@@ -258,7 +258,7 @@ private static byte EncodePublishPacket(MqttPublishPacket packet, IMqttPacketWri
                 propertiesWriter.WriteTopicAlias(packet.Properties.TopicAlias);
                 propertiesWriter.WriteResponseTopic(packet.Properties.ResponseTopic);
                 propertiesWriter.WriteCorrelationData(packet.Properties.CorrelationData);
-                propertiesWriter.WriteSubscriptionIdentifier(packet.Properties.SubscriptionIdentifier);
+                propertiesWriter.WriteSubscriptionIdentifiers(packet.Properties.SubscriptionIdentifiers);
                 propertiesWriter.WriteContentType(packet.Properties.ContentType);
                 propertiesWriter.WriteUserProperties(packet.Properties.UserProperties);
             }
diff --git a/Source/MQTTnet/Formatter/V5/MqttV500PropertiesReader.cs b/Source/MQTTnet/Formatter/V5/MqttV500PropertiesReader.cs
@@ -42,7 +42,7 @@ public bool MoveNext()
             return true;
         }
 
-        public void FillUserProperties(List<MqttUserProperty> userProperties)
+        public void AddUserPropertyTo(List<MqttUserProperty> userProperties)
         {
             if (userProperties == null) throw new ArgumentNullException(nameof(userProperties));
 
@@ -67,17 +67,17 @@ public byte[] ReadAuthenticationData()
             return _body.ReadWithLengthPrefix();
         }
 
-        public bool? ReadRetainAvailable()
+        public bool ReadRetainAvailable()
         {
             return _body.ReadBoolean();
         }
 
-        public uint? ReadSessionExpiryInterval()
+        public uint ReadSessionExpiryInterval()
         {
             return _body.ReadFourByteInteger();
         }
 
-        public ushort? ReadReceiveMaximum()
+        public ushort ReadReceiveMaximum()
         {
             return _body.ReadTwoByteInteger();
         }
@@ -92,17 +92,17 @@ public string ReadServerReference()
             return _body.ReadStringWithLengthPrefix();
         }
 
-        public ushort? ReadTopicAliasMaximum()
+        public ushort ReadTopicAliasMaximum()
         {
             return _body.ReadTwoByteInteger();
         }
 
-        public uint? ReadMaximumPacketSize()
+        public uint ReadMaximumPacketSize()
         {
             return _body.ReadFourByteInteger();
         }
 
-        public ushort? ReadServerKeepAlive()
+        public ushort ReadServerKeepAlive()
         {
             return _body.ReadTwoByteInteger();
         }
@@ -112,22 +112,22 @@ public string ReadResponseInformation()
             return _body.ReadStringWithLengthPrefix();
         }
 
-        public bool? ReadSharedSubscriptionAvailable()
+        public bool ReadSharedSubscriptionAvailable()
         {
             return _body.ReadBoolean();
         }
 
-        public bool? ReadSubscriptionIdentifiersAvailable()
+        public bool ReadSubscriptionIdentifiersAvailable()
         {
             return _body.ReadBoolean();
         }
 
-        public bool? ReadWildcardSubscriptionAvailable()
+        public bool ReadWildcardSubscriptionAvailable()
         {
             return _body.ReadBoolean();
         }
 
-        public uint? ReadSubscriptionIdentifier()
+        public uint ReadSubscriptionIdentifier()
         {
             return _body.ReadVariableLengthInteger();
         }
@@ -137,12 +137,12 @@ public string ReadResponseInformation()
             return (MqttPayloadFormatIndicator)_body.ReadByte();
         }
 
-        public uint? ReadMessageExpiryInterval()
+        public uint ReadMessageExpiryInterval()
         {
             return _body.ReadFourByteInteger();
         }
 
-        public ushort? ReadTopicAlias()
+        public ushort ReadTopicAlias()
         {
             return _body.ReadTwoByteInteger();
         }
@@ -162,17 +162,17 @@ public string ReadContentType()
             return _body.ReadStringWithLengthPrefix();
         }
 
-        public uint? ReadWillDelayInterval()
+        public uint ReadWillDelayInterval()
         {
             return _body.ReadFourByteInteger();
         }
 
-        public bool? RequestResponseInformation()
+        public bool RequestResponseInformation()
         {
             return _body.ReadBoolean();
         }
 
-        public bool? RequestProblemInformation()
+        public bool RequestProblemInformation()
         {
             return _body.ReadBoolean();
         }
diff --git a/Source/MQTTnet/Formatter/V5/MqttV500PropertiesWriter.cs b/Source/MQTTnet/Formatter/V5/MqttV500PropertiesWriter.cs
@@ -80,6 +80,19 @@ public void WriteSubscriptionIdentifier(uint? value)
             WriteAsVariableLengthInteger(MqttPropertyId.SubscriptionIdentifier, value);
         }
 
+        public void WriteSubscriptionIdentifiers(IEnumerable<uint> value)
+        {
+            if (value == null)
+            {
+                return;
+            }
+
+            foreach (var subscriptionIdentifier in value)
+            {
+                WriteAsVariableLengthInteger(MqttPropertyId.SubscriptionIdentifier, subscriptionIdentifier);
+            }
+        }
+
         public void WriteTopicAlias(ushort? value)
         {
             Write(MqttPropertyId.TopicAlias, value);
diff --git a/Source/MQTTnet/MqttApplicationMessage.cs b/Source/MQTTnet/MqttApplicationMessage.cs
@@ -28,6 +28,6 @@ public class MqttApplicationMessage
 
         public byte[] CorrelationData { get; set; }
 
-        public uint? SubscriptionIdentifier { get; set; }
+        public List<uint> SubscriptionIdentifiers { get; set; }
     }
 }
diff --git a/Source/MQTTnet/MqttApplicationMessageBuilder.cs b/Source/MQTTnet/MqttApplicationMessageBuilder.cs
diff --git a/Source/MQTTnet/Packets/MqttPublishPacketProperties.cs b/Source/MQTTnet/Packets/MqttPublishPacketProperties.cs
diff --git a/Tests/MQTTnet.Core.Tests/MqttPacketSerializer_Tests.cs b/Tests/MQTTnet.Core.Tests/MqttPacketSerializer_Tests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Collections.Generic;`
`2`	`3`	`using System.Linq;`
`3`	`4`	`using MQTTnet.Adapter;`
`4`	`5`	`using MQTTnet.Exceptions;`
`@@ -117,7 +118,7 @@ private static MqttBasePacket DecodeConnectPacket(IMqttPacketBodyReader body)`
`117`	`118`	`}`
`118`	`119`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`119`	`120`	`{`
`120`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`121`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`121`	`122`	`}`
`122`	`123`	`else`
`123`	`124`	`{`
`@@ -155,7 +156,12 @@ private static MqttBasePacket DecodeConnectPacket(IMqttPacketBodyReader body)`
`155`	`156`	`}`
`156`	`157`	`else if (willPropertiesReader.CurrentPropertyId == MqttPropertyId.SubscriptionIdentifier)`
`157`	`158`	`{`
`158`		`- packet.WillMessage.SubscriptionIdentifier = propertiesReader.ReadSubscriptionIdentifier();`
	`159`	`+ if (packet.WillMessage.SubscriptionIdentifiers == null)`
	`160`	`+ {`
	`161`	`+ packet.WillMessage.SubscriptionIdentifiers = new List<uint>();`
	`162`	`+ }`
	`163`	`+`
	`164`	`+ packet.WillMessage.SubscriptionIdentifiers.Add(propertiesReader.ReadSubscriptionIdentifier());`
`159`	`165`	`}`
`160`	`166`	`else if (willPropertiesReader.CurrentPropertyId == MqttPropertyId.ContentType)`
`161`	`167`	`{`
`@@ -168,7 +174,12 @@ private static MqttBasePacket DecodeConnectPacket(IMqttPacketBodyReader body)`
`168`	`174`	`}`
`169`	`175`	`else if (willPropertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`170`	`176`	`{`
`171`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`177`	`+ if (packet.WillMessage.UserProperties == null)`
	`178`	`+ {`
	`179`	`+ packet.WillMessage.UserProperties = new List<MqttUserProperty>();`
	`180`	`+ }`
	`181`	`+`
	`182`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`172`	`183`	`}`
`173`	`184`	`else`
`174`	`185`	`{`
`@@ -271,7 +282,7 @@ private static MqttBasePacket DecodeConnAckPacket(IMqttPacketBodyReader body)`
`271`	`282`	`}`
`272`	`283`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`273`	`284`	`{`
`274`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`285`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`275`	`286`	`}`
`276`	`287`	`else`
`277`	`288`	`{`
`@@ -309,7 +320,7 @@ private static MqttBasePacket DecodeDisconnectPacket(IMqttPacketBodyReader body)`
`309`	`320`	`}`
`310`	`321`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`311`	`322`	`{`
`312`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`323`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`313`	`324`	`}`
`314`	`325`	`else`
`315`	`326`	`{`
`@@ -339,7 +350,7 @@ private static MqttBasePacket DecodeSubscribePacket(IMqttPacketBodyReader body)`
`339`	`350`	`}`
`340`	`351`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`341`	`352`	`{`
`342`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`353`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`343`	`354`	`}`
`344`	`355`	`else`
`345`	`356`	`{`
`@@ -389,7 +400,7 @@ private static MqttBasePacket DecodeSubAckPacket(IMqttPacketBodyReader body)`
`389`	`400`	`}`
`390`	`401`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`391`	`402`	`{`
`392`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`403`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`393`	`404`	`}`
`394`	`405`	`else`
`395`	`406`	`{`
`@@ -421,7 +432,7 @@ private static MqttBasePacket DecodeUnsubscribePacket(IMqttPacketBodyReader body`
`421`	`432`	`{`
`422`	`433`	`if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`423`	`434`	`{`
`424`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`435`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`425`	`436`	`}`
`426`	`437`	`else`
`427`	`438`	`{`
`@@ -456,7 +467,7 @@ private static MqttBasePacket DecodeUnsubAckPacket(IMqttPacketBodyReader body)`
`456`	`467`	`}`
`457`	`468`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`458`	`469`	`{`
`459`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`470`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`460`	`471`	`}`
`461`	`472`	`else`
`462`	`473`	`{`
`@@ -530,15 +541,25 @@ private static MqttBasePacket DecodePublishPacket(byte header, IMqttPacketBodyRe`
`530`	`541`	`}`
`531`	`542`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.SubscriptionIdentifier)`
`532`	`543`	`{`
`533`		`- packet.Properties.SubscriptionIdentifier = propertiesReader.ReadSubscriptionIdentifier();`
	`544`	`+ if (packet.Properties.SubscriptionIdentifiers == null)`
	`545`	`+ {`
	`546`	`+ packet.Properties.SubscriptionIdentifiers = new List<uint>();`
	`547`	`+ }`
	`548`	`+`
	`549`	`+ packet.Properties.SubscriptionIdentifiers.Add(propertiesReader.ReadSubscriptionIdentifier());`
`534`	`550`	`}`
`535`	`551`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.ContentType)`
`536`	`552`	`{`
`537`	`553`	`packet.Properties.ContentType = propertiesReader.ReadContentType();`
`538`	`554`	`}`
`539`	`555`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`540`	`556`	`{`
`541`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`557`	`+ if (packet.Properties.UserProperties == null)`
	`558`	`+ {`
	`559`	`+ packet.Properties.UserProperties = new List<MqttUserProperty>();`
	`560`	`+ }`
	`561`	`+`
	`562`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`542`	`563`	`}`
`543`	`564`	`else`
`544`	`565`	`{`
`@@ -581,7 +602,7 @@ private static MqttBasePacket DecodePubAckPacket(IMqttPacketBodyReader body)`
`581`	`602`	`}`
`582`	`603`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`583`	`604`	`{`
`584`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`605`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`585`	`606`	`}`
`586`	`607`	`else`
`587`	`608`	`{`
`@@ -619,7 +640,7 @@ private static MqttBasePacket DecodePubRecPacket(IMqttPacketBodyReader body)`
`619`	`640`	`}`
`620`	`641`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`621`	`642`	`{`
`622`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`643`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`623`	`644`	`}`
`624`	`645`	`else`
`625`	`646`	`{`
`@@ -657,7 +678,7 @@ private static MqttBasePacket DecodePubRelPacket(IMqttPacketBodyReader body)`
`657`	`678`	`}`
`658`	`679`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`659`	`680`	`{`
`660`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`681`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`661`	`682`	`}`
`662`	`683`	`else`
`663`	`684`	`{`
`@@ -695,7 +716,7 @@ private static MqttBasePacket DecodePubCompPacket(IMqttPacketBodyReader body)`
`695`	`716`	`}`
`696`	`717`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`697`	`718`	`{`
`698`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`719`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`699`	`720`	`}`
`700`	`721`	`else`
`701`	`722`	`{`
`@@ -740,7 +761,7 @@ private static MqttBasePacket DecodeAuthPacket(IMqttPacketBodyReader body)`
`740`	`761`	`}`
`741`	`762`	`else if (propertiesReader.CurrentPropertyId == MqttPropertyId.UserProperty)`
`742`	`763`	`{`
`743`		`- propertiesReader.FillUserProperties(packet.Properties.UserProperties);`
	`764`	`+ propertiesReader.AddUserPropertyTo(packet.Properties.UserProperties);`
`744`	`765`	`}`
`745`	`766`	`else`
`746`	`767`	`{`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public bool MoveNext()`
`42`	`42`	`return true;`
`43`	`43`	`}`
`44`	`44`
`45`		`- public void FillUserProperties(List<MqttUserProperty> userProperties)`
	`45`	`+ public void AddUserPropertyTo(List<MqttUserProperty> userProperties)`
`46`	`46`	`{`
`47`	`47`	`if (userProperties == null) throw new ArgumentNullException(nameof(userProperties));`
`48`	`48`
`@@ -67,17 +67,17 @@ public byte[] ReadAuthenticationData()`
`67`	`67`	`return _body.ReadWithLengthPrefix();`
`68`	`68`	`}`
`69`	`69`
`70`		`- public bool? ReadRetainAvailable()`
	`70`	`+ public bool ReadRetainAvailable()`
`71`	`71`	`{`
`72`	`72`	`return _body.ReadBoolean();`
`73`	`73`	`}`
`74`	`74`
`75`		`- public uint? ReadSessionExpiryInterval()`
	`75`	`+ public uint ReadSessionExpiryInterval()`
`76`	`76`	`{`
`77`	`77`	`return _body.ReadFourByteInteger();`
`78`	`78`	`}`
`79`	`79`
`80`		`- public ushort? ReadReceiveMaximum()`
	`80`	`+ public ushort ReadReceiveMaximum()`
`81`	`81`	`{`
`82`	`82`	`return _body.ReadTwoByteInteger();`
`83`	`83`	`}`
`@@ -92,17 +92,17 @@ public string ReadServerReference()`
`92`	`92`	`return _body.ReadStringWithLengthPrefix();`
`93`	`93`	`}`
`94`	`94`
`95`		`- public ushort? ReadTopicAliasMaximum()`
	`95`	`+ public ushort ReadTopicAliasMaximum()`
`96`	`96`	`{`
`97`	`97`	`return _body.ReadTwoByteInteger();`
`98`	`98`	`}`
`99`	`99`
`100`		`- public uint? ReadMaximumPacketSize()`
	`100`	`+ public uint ReadMaximumPacketSize()`
`101`	`101`	`{`
`102`	`102`	`return _body.ReadFourByteInteger();`
`103`	`103`	`}`
`104`	`104`
`105`		`- public ushort? ReadServerKeepAlive()`
	`105`	`+ public ushort ReadServerKeepAlive()`
`106`	`106`	`{`
`107`	`107`	`return _body.ReadTwoByteInteger();`
`108`	`108`	`}`
`@@ -112,22 +112,22 @@ public string ReadResponseInformation()`
`112`	`112`	`return _body.ReadStringWithLengthPrefix();`
`113`	`113`	`}`
`114`	`114`
`115`		`- public bool? ReadSharedSubscriptionAvailable()`
	`115`	`+ public bool ReadSharedSubscriptionAvailable()`
`116`	`116`	`{`
`117`	`117`	`return _body.ReadBoolean();`
`118`	`118`	`}`
`119`	`119`
`120`		`- public bool? ReadSubscriptionIdentifiersAvailable()`
	`120`	`+ public bool ReadSubscriptionIdentifiersAvailable()`
`121`	`121`	`{`
`122`	`122`	`return _body.ReadBoolean();`
`123`	`123`	`}`
`124`	`124`
`125`		`- public bool? ReadWildcardSubscriptionAvailable()`
	`125`	`+ public bool ReadWildcardSubscriptionAvailable()`
`126`	`126`	`{`
`127`	`127`	`return _body.ReadBoolean();`
`128`	`128`	`}`
`129`	`129`
`130`		`- public uint? ReadSubscriptionIdentifier()`
	`130`	`+ public uint ReadSubscriptionIdentifier()`
`131`	`131`	`{`
`132`	`132`	`return _body.ReadVariableLengthInteger();`
`133`	`133`	`}`
`@@ -137,12 +137,12 @@ public string ReadResponseInformation()`
`137`	`137`	`return (MqttPayloadFormatIndicator)_body.ReadByte();`
`138`	`138`	`}`
`139`	`139`
`140`		`- public uint? ReadMessageExpiryInterval()`
	`140`	`+ public uint ReadMessageExpiryInterval()`
`141`	`141`	`{`
`142`	`142`	`return _body.ReadFourByteInteger();`
`143`	`143`	`}`
`144`	`144`
`145`		`- public ushort? ReadTopicAlias()`
	`145`	`+ public ushort ReadTopicAlias()`
`146`	`146`	`{`
`147`	`147`	`return _body.ReadTwoByteInteger();`
`148`	`148`	`}`
`@@ -162,17 +162,17 @@ public string ReadContentType()`
`162`	`162`	`return _body.ReadStringWithLengthPrefix();`
`163`	`163`	`}`
`164`	`164`
`165`		`- public uint? ReadWillDelayInterval()`
	`165`	`+ public uint ReadWillDelayInterval()`
`166`	`166`	`{`
`167`	`167`	`return _body.ReadFourByteInteger();`
`168`	`168`	`}`
`169`	`169`
`170`		`- public bool? RequestResponseInformation()`
	`170`	`+ public bool RequestResponseInformation()`
`171`	`171`	`{`
`172`	`172`	`return _body.ReadBoolean();`
`173`	`173`	`}`
`174`	`174`
`175`		`- public bool? RequestProblemInformation()`
	`175`	`+ public bool RequestProblemInformation()`
`176`	`176`	`{`
`177`	`177`	`return _body.ReadBoolean();`
`178`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,6 @@ public class MqttApplicationMessage`
`28`	`28`
`29`	`29`	`public byte[] CorrelationData { get; set; }`
`30`	`30`
`31`		`- public uint? SubscriptionIdentifier { get; set; }`
	`31`	`+ public List<uint> SubscriptionIdentifiers { get; set; }`
`32`	`32`	`}`
`33`	`33`	`}`