use Dictionary instead of interface for internal only methods

bollhals · bollhals · commit ccfddefd4a87 · 2020-05-25T21:57:52.000+02:00
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.cs
@@ -67,15 +67,15 @@ internal sealed class AutorecoveringConnection : IAutorecoveringConnection
 
         private readonly object _recordedEntitiesLock = new object();
 
-        private readonly IDictionary<string, RecordedExchange> _recordedExchanges = new Dictionary<string, RecordedExchange>();
+        private readonly Dictionary<string, RecordedExchange> _recordedExchanges = new Dictionary<string, RecordedExchange>();
 
-        private readonly IDictionary<string, RecordedQueue> _recordedQueues = new Dictionary<string, RecordedQueue>();
+        private readonly Dictionary<string, RecordedQueue> _recordedQueues = new Dictionary<string, RecordedQueue>();
 
-        private readonly IDictionary<RecordedBinding, byte> _recordedBindings = new Dictionary<RecordedBinding, byte>();
+        private readonly Dictionary<RecordedBinding, byte> _recordedBindings = new Dictionary<RecordedBinding, byte>();
 
-        private readonly IDictionary<string, RecordedConsumer> _recordedConsumers = new Dictionary<string, RecordedConsumer>();
+        private readonly Dictionary<string, RecordedConsumer> _recordedConsumers = new Dictionary<string, RecordedConsumer>();
 
-        private readonly ICollection<AutorecoveringModel> _models = new List<AutorecoveringModel>();
+        private readonly List<AutorecoveringModel> _models = new List<AutorecoveringModel>();
 
         private EventHandler<ConnectionBlockedEventArgs> _recordedBlockedEventHandlers;
         private EventHandler<ShutdownEventArgs> _recordedShutdownEventHandlers;
@@ -485,12 +485,11 @@ public void DeleteRecordedBinding(RecordedBinding rb)
 
         public RecordedConsumer DeleteRecordedConsumer(string consumerTag)
         {
-            RecordedConsumer rc = null;
+            RecordedConsumer rc;
             lock (_recordedEntitiesLock)
             {
-                if (_recordedConsumers.ContainsKey(consumerTag))
+                if (_recordedConsumers.TryGetValue(consumerTag, out rc))
                 {
-                    rc = _recordedConsumers[consumerTag];
                     _recordedConsumers.Remove(consumerTag);
                 }
             }
@@ -912,10 +911,12 @@ private void PropagateQueueNameChangeToBindings(string oldName, string newName)
         {
             lock (_recordedBindings)
             {
-                IEnumerable<RecordedBinding> bs = _recordedBindings.Keys.Where(b => b.Destination.Equals(oldName));
-                foreach (RecordedBinding b in bs)
+                foreach (RecordedBinding b in _recordedBindings.Keys)
                 {
-                    b.Destination = newName;
+                    if (b.Destination.Equals(oldName))
+                    {
+                        b.Destination = newName;
+                    }
                 }
             }
         }
@@ -924,21 +925,22 @@ private void PropagateQueueNameChangeToConsumers(string oldName, string newName)
         {
             lock (_recordedConsumers)
             {
-                IEnumerable<KeyValuePair<string, RecordedConsumer>> cs = _recordedConsumers.
-                    Where(pair => pair.Value.Queue.Equals(oldName));
-                foreach (KeyValuePair<string, RecordedConsumer> c in cs)
+                foreach (KeyValuePair<string, RecordedConsumer> c in _recordedConsumers)
                 {
-                    c.Value.Queue = newName;
+                    if (c.Value.Queue.Equals(oldName))
+                    {
+                        c.Value.Queue = newName;
+                    }
                 }
             }
         }
 
         private void RecoverBindings()
         {
-            IDictionary<RecordedBinding, byte> recordedBindingsCopy = null;
+            Dictionary<RecordedBinding, byte> recordedBindingsCopy;
             lock (_recordedBindings)
             {
-                recordedBindingsCopy = _recordedBindings.ToDictionary(e => e.Key, e => e.Value);
+                recordedBindingsCopy = new Dictionary<RecordedBinding, byte>(_recordedBindings);
             }
 
             foreach (RecordedBinding b in recordedBindingsCopy.Keys)
@@ -1031,10 +1033,10 @@ private void RecoverConsumers()
                 throw new ObjectDisposedException(GetType().FullName);
             }
 
-            IDictionary<string, RecordedConsumer> recordedConsumersCopy = null;
+            Dictionary<string, RecordedConsumer> recordedConsumersCopy;
             lock (_recordedConsumers)
             {
-                recordedConsumersCopy = _recordedConsumers.ToDictionary(e => e.Key, e => e.Value);
+                recordedConsumersCopy = new Dictionary<string, RecordedConsumer>(_recordedConsumers);
             }
 
             foreach (KeyValuePair<string, RecordedConsumer> pair in recordedConsumersCopy)
@@ -1091,10 +1093,10 @@ private void RecoverEntities()
 
         private void RecoverExchanges()
         {
-            IDictionary<string, RecordedExchange> recordedExchangesCopy = null;
+            Dictionary<string, RecordedExchange> recordedExchangesCopy;
             lock (_recordedEntitiesLock)
             {
-                recordedExchangesCopy = _recordedExchanges.ToDictionary(e => e.Key, e => e.Value);
+                recordedExchangesCopy = new Dictionary<string, RecordedExchange>(_recordedExchanges);
             }
 
             foreach (RecordedExchange rx in recordedExchangesCopy.Values)
@@ -1125,10 +1127,10 @@ private void RecoverModels()
 
         private void RecoverQueues()
         {
-            IDictionary<string, RecordedQueue> recordedQueuesCopy = null;
+            Dictionary<string, RecordedQueue> recordedQueuesCopy;
             lock (_recordedEntitiesLock)
             {
-                recordedQueuesCopy = _recordedQueues.ToDictionary(entry => entry.Key, entry => entry.Value);
+                recordedQueuesCopy = new Dictionary<string, RecordedQueue>(_recordedQueues);
             }
 
             foreach (KeyValuePair<string, RecordedQueue> pair in recordedQueuesCopy)
diff --git a/projects/RabbitMQ.Client/client/impl/BasicProperties.cs b/projects/RabbitMQ.Client/client/impl/BasicProperties.cs
@@ -284,11 +284,7 @@ public override object Clone()
             var clone = MemberwiseClone() as BasicProperties;
             if (IsHeadersPresent())
             {
-                clone.Headers = new Dictionary<string, object>();
-                foreach (KeyValuePair<string, object> entry in Headers)
-                {
-                    clone.Headers[entry.Key] = entry.Value;
-                }
+                clone.Headers = new Dictionary<string, object>(Headers);
             }
 
             return clone;
diff --git a/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyReader.cs b/projects/RabbitMQ.Client/client/impl/ContentHeaderPropertyReader.cs
@@ -45,7 +45,7 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    struct ContentHeaderPropertyReader
+    internal struct ContentHeaderPropertyReader
     {
         private ushort m_bitCount;
         private ushort m_flagWord;
@@ -143,9 +143,9 @@ public string ReadShortstr()
         }
 
         /// <returns>A type of <seealso cref="System.Collections.Generic.IDictionary{TKey,TValue}"/>.</returns>
-        public IDictionary<string, object> ReadTable()
+        public Dictionary<string, object> ReadTable()
         {
-            IDictionary<string, object> result = WireFormatting.ReadTable(_memory.Slice(_memoryOffset), out int bytesRead);
+            Dictionary<string, object> result = WireFormatting.ReadTable(_memory.Slice(_memoryOffset), out int bytesRead);
             _memoryOffset += bytesRead;
             return result;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/MethodArgumentReader.cs b/projects/RabbitMQ.Client/client/impl/MethodArgumentReader.cs
@@ -45,7 +45,7 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    struct MethodArgumentReader
+    internal struct MethodArgumentReader
     {
         private int? _bit;
         private int _bits;
@@ -125,10 +125,10 @@ public string ReadShortstr()
             return result;
         }
 
-        public IDictionary<string, object> ReadTable()
+        public Dictionary<string, object> ReadTable()
         {
             ClearBits();
-            IDictionary<string, object> result = WireFormatting.ReadTable(_memory.Slice(_memoryOffset), out int bytesRead);
+            Dictionary<string, object> result = WireFormatting.ReadTable(_memory.Slice(_memoryOffset), out int bytesRead);
             _memoryOffset += bytesRead;
             return result;
         }
diff --git a/projects/RabbitMQ.Client/client/impl/ProtocolBase.cs b/projects/RabbitMQ.Client/client/impl/ProtocolBase.cs
@@ -47,16 +47,19 @@ namespace RabbitMQ.Client.Framing.Impl
 {
     abstract class ProtocolBase : IProtocol
     {
-        public IDictionary<string, bool> Capabilities = new Dictionary<string, bool>();
+        public IDictionary<string, bool> Capabilities;
 
         public ProtocolBase()
         {
-            Capabilities["publisher_confirms"] = true;
-            Capabilities["exchange_exchange_bindings"] = true;
-            Capabilities["basic.nack"] = true;
-            Capabilities["consumer_cancel_notify"] = true;
-            Capabilities["connection.blocked"] = true;
-            Capabilities["authentication_failure_close"] = true;
+            Capabilities = new Dictionary<string, bool>
+            {
+                ["publisher_confirms"] = true,
+                ["exchange_exchange_bindings"] = true,
+                ["basic.nack"] = true,
+                ["consumer_cancel_notify"] = true,
+                ["connection.blocked"] = true,
+                ["authentication_failure_close"] = true
+            };
         }
 
         public abstract string ApiName { get; }
diff --git a/projects/RabbitMQ.Client/client/impl/SessionManager.cs b/projects/RabbitMQ.Client/client/impl/SessionManager.cs
@@ -55,7 +55,7 @@ class SessionManager
         public readonly ushort ChannelMax;
         private readonly IntAllocator _ints;
         private readonly Connection _connection;
-        private readonly IDictionary<int, ISession> _sessionMap = new Dictionary<int, ISession>();
+        private readonly Dictionary<int, ISession> _sessionMap = new Dictionary<int, ISession>();
         private bool _autoClose = false;
 
         public SessionManager(Connection connection, ushort channelMax)
diff --git a/projects/RabbitMQ.Client/client/impl/StreamProperties.cs b/projects/RabbitMQ.Client/client/impl/StreamProperties.cs
@@ -55,11 +55,7 @@ public override object Clone()
             var clone = MemberwiseClone() as StreamProperties;
             if (IsHeadersPresent())
             {
-                clone.Headers = new Dictionary<string, object>();
-                foreach (KeyValuePair<string, object> entry in Headers)
-                {
-                    clone.Headers[entry.Key] = entry.Value;
-                }
+                clone.Headers = new Dictionary<string, object>(Headers);
             }
 
             return clone;
diff --git a/projects/RabbitMQ.Client/client/impl/WireFormatting.cs b/projects/RabbitMQ.Client/client/impl/WireFormatting.cs
@@ -49,7 +49,7 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    class WireFormatting
+    internal class WireFormatting
     {
         public static decimal AmqpToDecimal(byte scale, uint unsignedMantissa)
         {
@@ -138,7 +138,7 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe
                     bytesRead += 8;
                     return ReadTimestamp(slice);
                 case 'F':
-                    IDictionary<string, object> tableResult = ReadTable(slice, out int tableBytesRead);
+                    Dictionary<string, object> tableResult = ReadTable(slice, out int tableBytesRead);
                     bytesRead += tableBytesRead;
                     return tableResult;
                 case 'A':
@@ -207,10 +207,10 @@ public static string ReadShortstr(ReadOnlyMemory<byte> memory, out int bytesRead
         /// and F, as well as the QPid-0-8 specific b, d, f, l, s, t,
         /// x and V types and the AMQP 0-9-1 A type.
         ///</remarks>
-        /// <returns>A <seealso cref="System.Collections.Generic.IDictionary{TKey,TValue}"/>.</returns>
-        public static IDictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory, out int bytesRead)
+        /// <returns>A <seealso cref="System.Collections.Generic.Dictionary{TKey,TValue}"/>.</returns>
+        public static Dictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory, out int bytesRead)
         {
-            IDictionary<string, object> table = new Dictionary<string, object>();
+            Dictionary<string, object> table = new Dictionary<string, object>();
             long tableLength = NetworkOrderDeserializer.ReadUInt32(memory);
             bytesRead = 4;
             while ((bytesRead - 4) < tableLength)
@@ -476,7 +476,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary<string, object> va
                 int bytesWritten = 0;
                 foreach (KeyValuePair<string, object> entry in val)
                 {
-                    bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key.ToString());
+                    bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key);
                     bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
                 }
 
@@ -512,7 +512,7 @@ public static int GetTableByteCount(IDictionary<string, object> val)
 
             foreach (KeyValuePair<string, object> entry in val)
             {
-                byteCount += Encoding.UTF8.GetByteCount(entry.Key.ToString()) + 1;
+                byteCount += Encoding.UTF8.GetByteCount(entry.Key) + 1;
                 byteCount += GetFieldValueByteCount(entry.Value);
             }
 

Original file line number	Diff line number	Diff line change
`@@ -67,15 +67,15 @@ internal sealed class AutorecoveringConnection : IAutorecoveringConnection`
`67`	`67`
`68`	`68`	`private readonly object _recordedEntitiesLock = new object();`
`69`	`69`
`70`		`- private readonly IDictionary<string, RecordedExchange> _recordedExchanges = new Dictionary<string, RecordedExchange>();`
	`70`	`+ private readonly Dictionary<string, RecordedExchange> _recordedExchanges = new Dictionary<string, RecordedExchange>();`
`71`	`71`
`72`		`- private readonly IDictionary<string, RecordedQueue> _recordedQueues = new Dictionary<string, RecordedQueue>();`
	`72`	`+ private readonly Dictionary<string, RecordedQueue> _recordedQueues = new Dictionary<string, RecordedQueue>();`
`73`	`73`
`74`		`- private readonly IDictionary<RecordedBinding, byte> _recordedBindings = new Dictionary<RecordedBinding, byte>();`
	`74`	`+ private readonly Dictionary<RecordedBinding, byte> _recordedBindings = new Dictionary<RecordedBinding, byte>();`
`75`	`75`
`76`		`- private readonly IDictionary<string, RecordedConsumer> _recordedConsumers = new Dictionary<string, RecordedConsumer>();`
	`76`	`+ private readonly Dictionary<string, RecordedConsumer> _recordedConsumers = new Dictionary<string, RecordedConsumer>();`
`77`	`77`
`78`		`- private readonly ICollection<AutorecoveringModel> _models = new List<AutorecoveringModel>();`
	`78`	`+ private readonly List<AutorecoveringModel> _models = new List<AutorecoveringModel>();`
`79`	`79`
`80`	`80`	`private EventHandler<ConnectionBlockedEventArgs> _recordedBlockedEventHandlers;`
`81`	`81`	`private EventHandler<ShutdownEventArgs> _recordedShutdownEventHandlers;`
`@@ -485,12 +485,11 @@ public void DeleteRecordedBinding(RecordedBinding rb)`
`485`	`485`
`486`	`486`	`public RecordedConsumer DeleteRecordedConsumer(string consumerTag)`
`487`	`487`	`{`
`488`		`- RecordedConsumer rc = null;`
	`488`	`+ RecordedConsumer rc;`
`489`	`489`	`lock (_recordedEntitiesLock)`
`490`	`490`	`{`
`491`		`- if (_recordedConsumers.ContainsKey(consumerTag))`
	`491`	`+ if (_recordedConsumers.TryGetValue(consumerTag, out rc))`
`492`	`492`	`{`
`493`		`- rc = _recordedConsumers[consumerTag];`
`494`	`493`	`_recordedConsumers.Remove(consumerTag);`
`495`	`494`	`}`
`496`	`495`	`}`
`@@ -912,10 +911,12 @@ private void PropagateQueueNameChangeToBindings(string oldName, string newName)`
`912`	`911`	`{`
`913`	`912`	`lock (_recordedBindings)`
`914`	`913`	`{`
`915`		`- IEnumerable<RecordedBinding> bs = _recordedBindings.Keys.Where(b => b.Destination.Equals(oldName));`
`916`		`- foreach (RecordedBinding b in bs)`
	`914`	`+ foreach (RecordedBinding b in _recordedBindings.Keys)`
`917`	`915`	`{`
`918`		`- b.Destination = newName;`
	`916`	`+ if (b.Destination.Equals(oldName))`
	`917`	`+ {`
	`918`	`+ b.Destination = newName;`
	`919`	`+ }`
`919`	`920`	`}`
`920`	`921`	`}`
`921`	`922`	`}`
`@@ -924,21 +925,22 @@ private void PropagateQueueNameChangeToConsumers(string oldName, string newName)`
`924`	`925`	`{`
`925`	`926`	`lock (_recordedConsumers)`
`926`	`927`	`{`
`927`		`- IEnumerable<KeyValuePair<string, RecordedConsumer>> cs = _recordedConsumers.`
`928`		`- Where(pair => pair.Value.Queue.Equals(oldName));`
`929`		`- foreach (KeyValuePair<string, RecordedConsumer> c in cs)`
	`928`	`+ foreach (KeyValuePair<string, RecordedConsumer> c in _recordedConsumers)`
`930`	`929`	`{`
`931`		`- c.Value.Queue = newName;`
	`930`	`+ if (c.Value.Queue.Equals(oldName))`
	`931`	`+ {`
	`932`	`+ c.Value.Queue = newName;`
	`933`	`+ }`
`932`	`934`	`}`
`933`	`935`	`}`
`934`	`936`	`}`
`935`	`937`
`936`	`938`	`private void RecoverBindings()`
`937`	`939`	`{`
`938`		`- IDictionary<RecordedBinding, byte> recordedBindingsCopy = null;`
	`940`	`+ Dictionary<RecordedBinding, byte> recordedBindingsCopy;`
`939`	`941`	`lock (_recordedBindings)`
`940`	`942`	`{`
`941`		`- recordedBindingsCopy = _recordedBindings.ToDictionary(e => e.Key, e => e.Value);`
	`943`	`+ recordedBindingsCopy = new Dictionary<RecordedBinding, byte>(_recordedBindings);`
`942`	`944`	`}`
`943`	`945`
`944`	`946`	`foreach (RecordedBinding b in recordedBindingsCopy.Keys)`
`@@ -1031,10 +1033,10 @@ private void RecoverConsumers()`
`1031`	`1033`	`throw new ObjectDisposedException(GetType().FullName);`
`1032`	`1034`	`}`
`1033`	`1035`
`1034`		`- IDictionary<string, RecordedConsumer> recordedConsumersCopy = null;`
	`1036`	`+ Dictionary<string, RecordedConsumer> recordedConsumersCopy;`
`1035`	`1037`	`lock (_recordedConsumers)`
`1036`	`1038`	`{`
`1037`		`- recordedConsumersCopy = _recordedConsumers.ToDictionary(e => e.Key, e => e.Value);`
	`1039`	`+ recordedConsumersCopy = new Dictionary<string, RecordedConsumer>(_recordedConsumers);`
`1038`	`1040`	`}`
`1039`	`1041`
`1040`	`1042`	`foreach (KeyValuePair<string, RecordedConsumer> pair in recordedConsumersCopy)`
`@@ -1091,10 +1093,10 @@ private void RecoverEntities()`
`1091`	`1093`
`1092`	`1094`	`private void RecoverExchanges()`
`1093`	`1095`	`{`
`1094`		`- IDictionary<string, RecordedExchange> recordedExchangesCopy = null;`
	`1096`	`+ Dictionary<string, RecordedExchange> recordedExchangesCopy;`
`1095`	`1097`	`lock (_recordedEntitiesLock)`
`1096`	`1098`	`{`
`1097`		`- recordedExchangesCopy = _recordedExchanges.ToDictionary(e => e.Key, e => e.Value);`
	`1099`	`+ recordedExchangesCopy = new Dictionary<string, RecordedExchange>(_recordedExchanges);`
`1098`	`1100`	`}`
`1099`	`1101`
`1100`	`1102`	`foreach (RecordedExchange rx in recordedExchangesCopy.Values)`
`@@ -1125,10 +1127,10 @@ private void RecoverModels()`
`1125`	`1127`
`1126`	`1128`	`private void RecoverQueues()`
`1127`	`1129`	`{`
`1128`		`- IDictionary<string, RecordedQueue> recordedQueuesCopy = null;`
	`1130`	`+ Dictionary<string, RecordedQueue> recordedQueuesCopy;`
`1129`	`1131`	`lock (_recordedEntitiesLock)`
`1130`	`1132`	`{`
`1131`		`- recordedQueuesCopy = _recordedQueues.ToDictionary(entry => entry.Key, entry => entry.Value);`
	`1133`	`+ recordedQueuesCopy = new Dictionary<string, RecordedQueue>(_recordedQueues);`
`1132`	`1134`	`}`
`1133`	`1135`
`1134`	`1136`	`foreach (KeyValuePair<string, RecordedQueue> pair in recordedQueuesCopy)`
Original file line number	Diff line number	Diff line change
`@@ -284,11 +284,7 @@ public override object Clone()`
`284`	`284`	`var clone = MemberwiseClone() as BasicProperties;`
`285`	`285`	`if (IsHeadersPresent())`
`286`	`286`	`{`
`287`		`- clone.Headers = new Dictionary<string, object>();`
`288`		`- foreach (KeyValuePair<string, object> entry in Headers)`
`289`		`- {`
`290`		`- clone.Headers[entry.Key] = entry.Value;`
`291`		`- }`
	`287`	`+ clone.Headers = new Dictionary<string, object>(Headers);`
`292`	`288`	`}`
`293`	`289`
`294`	`290`	`return clone;`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@`
`45`	`45`
`46`	`46`	`namespace RabbitMQ.Client.Impl`
`47`	`47`	`{`
`48`		`- struct ContentHeaderPropertyReader`
	`48`	`+ internal struct ContentHeaderPropertyReader`
`49`	`49`	`{`
`50`	`50`	`private ushort m_bitCount;`
`51`	`51`	`private ushort m_flagWord;`
`@@ -143,9 +143,9 @@ public string ReadShortstr()`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`/// <returns>A type of <seealso cref="System.Collections.Generic.IDictionary{TKey,TValue}"/>.</returns>`
`146`		`- public IDictionary<string, object> ReadTable()`
	`146`	`+ public Dictionary<string, object> ReadTable()`
`147`	`147`	`{`
`148`		`- IDictionary<string, object> result = WireFormatting.ReadTable(_memory.Slice(_memoryOffset), out int bytesRead);`
	`148`	`+ Dictionary<string, object> result = WireFormatting.ReadTable(_memory.Slice(_memoryOffset), out int bytesRead);`
`149`	`149`	`_memoryOffset += bytesRead;`
`150`	`150`	`return result;`
`151`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,11 +55,7 @@ public override object Clone()`
`55`	`55`	`var clone = MemberwiseClone() as StreamProperties;`
`56`	`56`	`if (IsHeadersPresent())`
`57`	`57`	`{`
`58`		`- clone.Headers = new Dictionary<string, object>();`
`59`		`- foreach (KeyValuePair<string, object> entry in Headers)`
`60`		`- {`
`61`		`- clone.Headers[entry.Key] = entry.Value;`
`62`		`- }`
	`58`	`+ clone.Headers = new Dictionary<string, object>(Headers);`
`63`	`59`	`}`
`64`	`60`
`65`	`61`	`return clone;`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@`
`49`	`49`
`50`	`50`	`namespace RabbitMQ.Client.Impl`
`51`	`51`	`{`
`52`		`- class WireFormatting`
	`52`	`+ internal class WireFormatting`
`53`	`53`	`{`
`54`	`54`	`public static decimal AmqpToDecimal(byte scale, uint unsignedMantissa)`
`55`	`55`	`{`
`@@ -138,7 +138,7 @@ public static object ReadFieldValue(ReadOnlyMemory<byte> memory, out int bytesRe`
`138`	`138`	`bytesRead += 8;`
`139`	`139`	`return ReadTimestamp(slice);`
`140`	`140`	`case 'F':`
`141`		`- IDictionary<string, object> tableResult = ReadTable(slice, out int tableBytesRead);`
	`141`	`+ Dictionary<string, object> tableResult = ReadTable(slice, out int tableBytesRead);`
`142`	`142`	`bytesRead += tableBytesRead;`
`143`	`143`	`return tableResult;`
`144`	`144`	`case 'A':`
`@@ -207,10 +207,10 @@ public static string ReadShortstr(ReadOnlyMemory<byte> memory, out int bytesRead`
`207`	`207`	`/// and F, as well as the QPid-0-8 specific b, d, f, l, s, t,`
`208`	`208`	`/// x and V types and the AMQP 0-9-1 A type.`
`209`	`209`	`///</remarks>`
`210`		`- /// <returns>A <seealso cref="System.Collections.Generic.IDictionary{TKey,TValue}"/>.</returns>`
`211`		`- public static IDictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory, out int bytesRead)`
	`210`	`+ /// <returns>A <seealso cref="System.Collections.Generic.Dictionary{TKey,TValue}"/>.</returns>`
	`211`	`+ public static Dictionary<string, object> ReadTable(ReadOnlyMemory<byte> memory, out int bytesRead)`
`212`	`212`	`{`
`213`		`- IDictionary<string, object> table = new Dictionary<string, object>();`
	`213`	`+ Dictionary<string, object> table = new Dictionary<string, object>();`
`214`	`214`	`long tableLength = NetworkOrderDeserializer.ReadUInt32(memory);`
`215`	`215`	`bytesRead = 4;`
`216`	`216`	`while ((bytesRead - 4) < tableLength)`
`@@ -476,7 +476,7 @@ public static int WriteTable(Memory<byte> memory, IDictionary<string, object> va`
`476`	`476`	`int bytesWritten = 0;`
`477`	`477`	`foreach (KeyValuePair<string, object> entry in val)`
`478`	`478`	`{`
`479`		`- bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key.ToString());`
	`479`	`+ bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key);`
`480`	`480`	`bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);`
`481`	`481`	`}`
`482`	`482`
`@@ -512,7 +512,7 @@ public static int GetTableByteCount(IDictionary<string, object> val)`
`512`	`512`
`513`	`513`	`foreach (KeyValuePair<string, object> entry in val)`
`514`	`514`	`{`
`515`		`- byteCount += Encoding.UTF8.GetByteCount(entry.Key.ToString()) + 1;`
	`515`	`+ byteCount += Encoding.UTF8.GetByteCount(entry.Key) + 1;`
`516`	`516`	`byteCount += GetFieldValueByteCount(entry.Value);`
`517`	`517`	`}`
`518`	`518`