Merge branch 'bollhals-minor.improvements'

michaelklishin · michaelklishin · commit 6a0488ee2d38 · 2020-05-26T17:43:31.000+03:00
diff --git a/projects/RabbitMQ.Client/client/api/ConnectionFactory.cs b/projects/RabbitMQ.Client/client/api/ConnectionFactory.cs
@@ -329,14 +329,16 @@ public Uri Uri
         public IAuthMechanismFactory AuthMechanismFactory(IList<string> mechanismNames)
         {
             // Our list is in order of preference, the server one is not.
-            foreach (IAuthMechanismFactory factory in AuthMechanisms)
+            for (int index = 0; index < AuthMechanisms.Count; index++)
             {
+                IAuthMechanismFactory factory = AuthMechanisms[index];
                 string factoryName = factory.Name;
                 if (mechanismNames.Any<string>(x => string.Equals(x, factoryName, StringComparison.OrdinalIgnoreCase)))
                 {
                     return factory;
                 }
             }
+
             return null;
         }
 
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/Connection.cs b/projects/RabbitMQ.Client/client/impl/Connection.cs
@@ -730,10 +730,9 @@ public void PrettyPrintShutdownReport()
             {
                 Console.Error.WriteLine(
 "Log of errors while closing connection {0}:", this);
-                foreach (ShutdownReportEntry entry in ShutdownReport)
+                for (int index = 0; index < ShutdownReport.Count; index++)
                 {
-                    Console.Error.WriteLine(
-entry.ToString());
+                    Console.Error.WriteLine(ShutdownReport[index].ToString());
                 }
             }
         }
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/ModelBase.cs b/projects/RabbitMQ.Client/client/impl/ModelBase.cs
@@ -55,12 +55,12 @@ namespace RabbitMQ.Client.Impl
 {
     abstract class ModelBase : IFullModel, IRecoverable
     {
-        public readonly IDictionary<string, IBasicConsumer> m_consumers = new Dictionary<string, IBasicConsumer>();
-
         ///<summary>Only used to kick-start a connection open
         ///sequence. See <see cref="Connection.Open"/> </summary>
         public BlockingCell<ConnectionStartDetails> m_connectionStartCell = null;
 
+        private readonly Dictionary<string, IBasicConsumer> _consumers = new Dictionary<string, IBasicConsumer>();
+
         private TimeSpan _handshakeContinuationTimeout = TimeSpan.FromSeconds(10);
         private TimeSpan _continuationTimeout = TimeSpan.FromSeconds(20);
 
@@ -500,11 +500,11 @@ public void OnSessionShutdown(object sender, ShutdownEventArgs reason)
             ConsumerDispatcher.Quiesce();
             SetCloseReason(reason);
             OnModelShutdown(reason);
-            BroadcastShutdownToConsumers(m_consumers, reason);
+            BroadcastShutdownToConsumers(_consumers, reason);
             ConsumerDispatcher.Shutdown(this).GetAwaiter().GetResult();;
         }
 
-        protected void BroadcastShutdownToConsumers(IDictionary<string, IBasicConsumer> cs, ShutdownEventArgs reason)
+        protected void BroadcastShutdownToConsumers(Dictionary<string, IBasicConsumer> cs, ShutdownEventArgs reason)
         {
             foreach (KeyValuePair<string, IBasicConsumer> c in cs)
             {
@@ -578,10 +578,10 @@ public void HandleBasicAck(ulong deliveryTag,
         public void HandleBasicCancel(string consumerTag, bool nowait)
         {
             IBasicConsumer consumer;
-            lock (m_consumers)
+            lock (_consumers)
             {
-                consumer = m_consumers[consumerTag];
-                m_consumers.Remove(consumerTag);
+                consumer = _consumers[consumerTag];
+                _consumers.Remove(consumerTag);
             }
             if (consumer == null)
             {
@@ -601,10 +601,10 @@ public void HandleBasicCancelOk(string consumerTag)
                             consumerTag
                             ));
             */
-            lock (m_consumers)
+            lock (_consumers)
             {
-                k.m_consumer = m_consumers[consumerTag];
-                m_consumers.Remove(consumerTag);
+                k.m_consumer = _consumers[consumerTag];
+                _consumers.Remove(consumerTag);
             }
             ConsumerDispatcher.HandleBasicCancelOk(k.m_consumer, consumerTag);
             k.HandleCommand(null); // release the continuation.
@@ -615,9 +615,9 @@ public void HandleBasicConsumeOk(string consumerTag)
             var k =
                 (BasicConsumerRpcContinuation)_continuationQueue.Next();
             k.m_consumerTag = consumerTag;
-            lock (m_consumers)
+            lock (_consumers)
             {
-                m_consumers[consumerTag] = k.m_consumer;
+                _consumers[consumerTag] = k.m_consumer;
             }
             ConsumerDispatcher.HandleBasicConsumeOk(k.m_consumer, consumerTag);
             k.HandleCommand(null); // release the continuation.
@@ -632,9 +632,9 @@ public virtual void HandleBasicDeliver(string consumerTag,
             ReadOnlyMemory<byte> body)
         {
             IBasicConsumer consumer;
-            lock (m_consumers)
+            lock (_consumers)
             {
-                consumer = m_consumers[consumerTag];
+                consumer = _consumers[consumerTag];
             }
             if (consumer == null)
             {
@@ -1005,9 +1005,9 @@ public void BasicCancel(string consumerTag)
                 k.GetReply(ContinuationTimeout);
             }
 
-            lock (m_consumers)
+            lock (_consumers)
             {
-                m_consumers.Remove(consumerTag);
+                _consumers.Remove(consumerTag);
             }
 
             ModelShutdown -= k.m_consumer.HandleModelShutdown;
@@ -1017,9 +1017,9 @@ public void BasicCancelNoWait(string consumerTag)
         {
             _Private_BasicCancel(consumerTag, true);
 
-            lock (m_consumers)
+            lock (_consumers)
             {
-                m_consumers.Remove(consumerTag);
+                _consumers.Remove(consumerTag);
             }
         }
 
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/Session.cs b/projects/RabbitMQ.Client/client/impl/Session.cs
@@ -55,9 +55,10 @@ public Session(Connection connection, int channelNumber)
 
         public override void HandleFrame(in InboundFrame frame)
         {
-            using (Command cmd = _assembler.HandleFrame(in frame))
+            Command cmd = _assembler.HandleFrame(in frame);
+            if (cmd != null)
             {
-                if (cmd != null)
+                using (cmd)
                 {
                     OnCommandReceived(cmd);
                 }
diff --git a/projects/RabbitMQ.Client/client/impl/SessionManager.cs b/projects/RabbitMQ.Client/client/impl/SessionManager.cs
@@ -50,7 +50,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>();
 
         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

Original file line number	Diff line number	Diff line change
`@@ -329,14 +329,16 @@ public Uri Uri`
`329`	`329`	`public IAuthMechanismFactory AuthMechanismFactory(IList<string> mechanismNames)`
`330`	`330`	`{`
`331`	`331`	`// Our list is in order of preference, the server one is not.`
`332`		`- foreach (IAuthMechanismFactory factory in AuthMechanisms)`
	`332`	`+ for (int index = 0; index < AuthMechanisms.Count; index++)`
`333`	`333`	`{`
	`334`	`+ IAuthMechanismFactory factory = AuthMechanisms[index];`
`334`	`335`	`string factoryName = factory.Name;`
`335`	`336`	`if (mechanismNames.Any<string>(x => string.Equals(x, factoryName, StringComparison.OrdinalIgnoreCase)))`
`336`	`337`	`{`
`337`	`338`	`return factory;`
`338`	`339`	`}`
`339`	`340`	`}`
	`341`	`+`
`340`	`342`	`return null;`
`341`	`343`	`}`
`342`	`344`
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
`@@ -730,10 +730,9 @@ public void PrettyPrintShutdownReport()`
`730`	`730`	`{`
`731`	`731`	`Console.Error.WriteLine(`
`732`	`732`	`"Log of errors while closing connection {0}:", this);`
`733`		`- foreach (ShutdownReportEntry entry in ShutdownReport)`
	`733`	`+ for (int index = 0; index < ShutdownReport.Count; index++)`
`734`	`734`	`{`
`735`		`- Console.Error.WriteLine(`
`736`		`-entry.ToString());`
	`735`	`+ Console.Error.WriteLine(ShutdownReport[index].ToString());`
`737`	`736`	`}`
`738`	`737`	`}`
`739`	`738`	`}`
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,12 +55,12 @@ namespace RabbitMQ.Client.Impl`
`55`	`55`	`{`
`56`	`56`	`abstract class ModelBase : IFullModel, IRecoverable`
`57`	`57`	`{`
`58`		`- public readonly IDictionary<string, IBasicConsumer> m_consumers = new Dictionary<string, IBasicConsumer>();`
`59`		`-`
`60`	`58`	`///<summary>Only used to kick-start a connection open`
`61`	`59`	`///sequence. See <see cref="Connection.Open"/> </summary>`
`62`	`60`	`public BlockingCell<ConnectionStartDetails> m_connectionStartCell = null;`
`63`	`61`
	`62`	`+ private readonly Dictionary<string, IBasicConsumer> _consumers = new Dictionary<string, IBasicConsumer>();`
	`63`	`+`
`64`	`64`	`private TimeSpan _handshakeContinuationTimeout = TimeSpan.FromSeconds(10);`
`65`	`65`	`private TimeSpan _continuationTimeout = TimeSpan.FromSeconds(20);`
`66`	`66`
`@@ -500,11 +500,11 @@ public void OnSessionShutdown(object sender, ShutdownEventArgs reason)`
`500`	`500`	`ConsumerDispatcher.Quiesce();`
`501`	`501`	`SetCloseReason(reason);`
`502`	`502`	`OnModelShutdown(reason);`
`503`		`- BroadcastShutdownToConsumers(m_consumers, reason);`
	`503`	`+ BroadcastShutdownToConsumers(_consumers, reason);`
`504`	`504`	`ConsumerDispatcher.Shutdown(this).GetAwaiter().GetResult();;`
`505`	`505`	`}`
`506`	`506`
`507`		`- protected void BroadcastShutdownToConsumers(IDictionary<string, IBasicConsumer> cs, ShutdownEventArgs reason)`
	`507`	`+ protected void BroadcastShutdownToConsumers(Dictionary<string, IBasicConsumer> cs, ShutdownEventArgs reason)`
`508`	`508`	`{`
`509`	`509`	`foreach (KeyValuePair<string, IBasicConsumer> c in cs)`
`510`	`510`	`{`
`@@ -578,10 +578,10 @@ public void HandleBasicAck(ulong deliveryTag,`
`578`	`578`	`public void HandleBasicCancel(string consumerTag, bool nowait)`
`579`	`579`	`{`
`580`	`580`	`IBasicConsumer consumer;`
`581`		`- lock (m_consumers)`
	`581`	`+ lock (_consumers)`
`582`	`582`	`{`
`583`		`- consumer = m_consumers[consumerTag];`
`584`		`- m_consumers.Remove(consumerTag);`
	`583`	`+ consumer = _consumers[consumerTag];`
	`584`	`+ _consumers.Remove(consumerTag);`
`585`	`585`	`}`
`586`	`586`	`if (consumer == null)`
`587`	`587`	`{`
`@@ -601,10 +601,10 @@ public void HandleBasicCancelOk(string consumerTag)`
`601`	`601`	`consumerTag`
`602`	`602`	`));`
`603`	`603`	`*/`
`604`		`- lock (m_consumers)`
	`604`	`+ lock (_consumers)`
`605`	`605`	`{`
`606`		`- k.m_consumer = m_consumers[consumerTag];`
`607`		`- m_consumers.Remove(consumerTag);`
	`606`	`+ k.m_consumer = _consumers[consumerTag];`
	`607`	`+ _consumers.Remove(consumerTag);`
`608`	`608`	`}`
`609`	`609`	`ConsumerDispatcher.HandleBasicCancelOk(k.m_consumer, consumerTag);`
`610`	`610`	`k.HandleCommand(null); // release the continuation.`
`@@ -615,9 +615,9 @@ public void HandleBasicConsumeOk(string consumerTag)`
`615`	`615`	`var k =`
`616`	`616`	`(BasicConsumerRpcContinuation)_continuationQueue.Next();`
`617`	`617`	`k.m_consumerTag = consumerTag;`
`618`		`- lock (m_consumers)`
	`618`	`+ lock (_consumers)`
`619`	`619`	`{`
`620`		`- m_consumers[consumerTag] = k.m_consumer;`
	`620`	`+ _consumers[consumerTag] = k.m_consumer;`
`621`	`621`	`}`
`622`	`622`	`ConsumerDispatcher.HandleBasicConsumeOk(k.m_consumer, consumerTag);`
`623`	`623`	`k.HandleCommand(null); // release the continuation.`
`@@ -632,9 +632,9 @@ public virtual void HandleBasicDeliver(string consumerTag,`
`632`	`632`	`ReadOnlyMemory<byte> body)`
`633`	`633`	`{`
`634`	`634`	`IBasicConsumer consumer;`
`635`		`- lock (m_consumers)`
	`635`	`+ lock (_consumers)`
`636`	`636`	`{`
`637`		`- consumer = m_consumers[consumerTag];`
	`637`	`+ consumer = _consumers[consumerTag];`
`638`	`638`	`}`
`639`	`639`	`if (consumer == null)`
`640`	`640`	`{`
`@@ -1005,9 +1005,9 @@ public void BasicCancel(string consumerTag)`
`1005`	`1005`	`k.GetReply(ContinuationTimeout);`
`1006`	`1006`	`}`
`1007`	`1007`
`1008`		`- lock (m_consumers)`
	`1008`	`+ lock (_consumers)`
`1009`	`1009`	`{`
`1010`		`- m_consumers.Remove(consumerTag);`
	`1010`	`+ _consumers.Remove(consumerTag);`
`1011`	`1011`	`}`
`1012`	`1012`
`1013`	`1013`	`ModelShutdown -= k.m_consumer.HandleModelShutdown;`
`@@ -1017,9 +1017,9 @@ public void BasicCancelNoWait(string consumerTag)`
`1017`	`1017`	`{`
`1018`	`1018`	`_Private_BasicCancel(consumerTag, true);`
`1019`	`1019`
`1020`		`- lock (m_consumers)`
	`1020`	`+ lock (_consumers)`
`1021`	`1021`	`{`
`1022`		`- m_consumers.Remove(consumerTag);`
	`1022`	`+ _consumers.Remove(consumerTag);`
`1023`	`1023`	`}`
`1024`	`1024`	`}`
`1025`	`1025`
Original file line number	Diff line number	Diff line change
`@@ -55,9 +55,10 @@ public Session(Connection connection, int channelNumber)`
`55`	`55`
`56`	`56`	`public override void HandleFrame(in InboundFrame frame)`
`57`	`57`	`{`
`58`		`- using (Command cmd = _assembler.HandleFrame(in frame))`
	`58`	`+ Command cmd = _assembler.HandleFrame(in frame);`
	`59`	`+ if (cmd != null)`
`59`	`60`	`{`
`60`		`- if (cmd != null)`
	`61`	`+ using (cmd)`
`61`	`62`	`{`
`62`	`63`	`OnCommandReceived(cmd);`
`63`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ class SessionManager`
`50`	`50`	`public readonly ushort ChannelMax;`
`51`	`51`	`private readonly IntAllocator _ints;`
`52`	`52`	`private readonly Connection _connection;`
`53`		`- private readonly IDictionary<int, ISession> _sessionMap = new Dictionary<int, ISession>();`
	`53`	`+ private readonly Dictionary<int, ISession> _sessionMap = new Dictionary<int, ISession>();`
`54`	`54`
`55`	`55`	`public SessionManager(Connection connection, ushort channelMax)`
`56`	`56`	`{`
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;`