* Ensure that AmqpString comparison works the expected way when ReadOnlyMemory<byte> is used.

Author: lukebakken

projects/RabbitMQ.Client/client/api/AmqpString.cs

@@ -32,6 +32,7 @@
 using System;
 using System.Text;
 using System.Text.RegularExpressions;
+using RabbitMQ.Util;
 
 namespace RabbitMQ.Client
 {
@@ -169,7 +170,7 @@ public override int GetHashCode()
         {
             if (_value == null)
             {
-                return _stringBytes.GetHashCode();
+                return ReadOnlyMemoryOfByteEqualityComparer.CalculateHashCode(_stringBytes);
             }
             else
             {
@@ -179,7 +180,14 @@ public override int GetHashCode()
 
         public int CompareTo(AmqpString other)
         {
-            return Value.CompareTo(other.Value);
+            if (_value == null)
+            {
+                return GetHashCode().CompareTo(other.GetHashCode());
+            }
+            else
+            {
+                return Value.CompareTo(other.Value);
+            }
         }
 
         public static bool operator ==(AmqpString amqpString1, AmqpString amqpString2)

projects/RabbitMQ.Client/client/impl/ConsumerDispatching/ConsumerDispatcherBase.cs

@@ -16,7 +16,8 @@ internal abstract class ConsumerDispatcherBase
 
         protected ConsumerDispatcherBase()
         {
-            _consumers = new Dictionary<ReadOnlyMemory<byte>, (IBasicConsumer, ConsumerTag)>(MemoryOfByteEqualityComparer.Instance);
+            IEqualityComparer<ReadOnlyMemory<byte>> comparer = new ReadOnlyMemoryOfByteEqualityComparer();
+            _consumers = new Dictionary<ReadOnlyMemory<byte>, (IBasicConsumer, ConsumerTag)>(comparer);
         }
 
         protected void AddConsumer(IBasicConsumer consumer, ConsumerTag consumerTag)

projects/RabbitMQ.Client/client/impl/RabbitMQActivitySource.cs

@@ -1,10 +1,8 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Net;
 using System.Net.Sockets;
 using System.Reflection;
-using System.Runtime.CompilerServices;
 using System.Text;
 using RabbitMQ.Client.Events;
 using RabbitMQ.Client.Impl;
@@ -112,28 +110,6 @@ internal static Activity Receive(string routingKey, string exchange, ulong deliv
             return activity;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static string GetString(ReadOnlySpan<byte> span)
-        {
-#if NETSTANDARD
-            if (span.Length == 0)
-            {
-                return string.Empty;
-            }
-
-            unsafe
-            {
-                fixed (byte* bytesPtr = span)
-                {
-                    return Encoding.UTF8.GetString(bytesPtr, span.Length);
-                }
-            }
-#else
-            return Encoding.UTF8.GetString(span);
-#endif
-        }
-
-
         internal static Activity Deliver(BasicDeliverEventArgs deliverEventArgs)
         {
             if (!s_subscriberSource.HasListeners())

projects/RabbitMQ.Client/client/impl/RecordedQueue.cs

@@ -86,7 +86,7 @@ public async Task<QueueName> RecoverAsync(IChannel channel, CancellationToken ca
                 cancellationToken: cancellationToken)
                     .ConfigureAwait(false);
 
-            return new QueueName(queueDeclareResult.QueueName);
+            return (QueueName)queueDeclareResult;
         }
 
         public override string ToString()

projects/RabbitMQ.Client/util/MemoryOfByteEqualityComparer.cs renamed to projects/RabbitMQ.Client/util/ReadOnlyMemoryOfByteEqualityComparer.cs

@@ -35,34 +35,37 @@
 
 namespace RabbitMQ.Util
 {
-    internal sealed class MemoryOfByteEqualityComparer : IEqualityComparer<ReadOnlyMemory<byte>>
+    internal sealed class ReadOnlyMemoryOfByteEqualityComparer : IEqualityComparer<ReadOnlyMemory<byte>>
     {
-        public static MemoryOfByteEqualityComparer Instance { get; } = new MemoryOfByteEqualityComparer();
-
         public bool Equals(ReadOnlyMemory<byte> left, ReadOnlyMemory<byte> right)
         {
             return left.Span.SequenceEqual(right.Span);
         }
 
         public int GetHashCode(ReadOnlyMemory<byte> value)
         {
+            return CalculateHashCode(value);
+        }
+
+        public static int CalculateHashCode(ReadOnlyMemory<byte> value)
+        {
 #if NETSTANDARD
-                unchecked
+            unchecked
+            {
+                int hashCode = 0;
+                ReadOnlySpan<long> longPart = MemoryMarshal.Cast<byte, long>(value.Span);
+                foreach (long item in longPart)
                 {
-                    int hashCode = 0;
-                    var longPart = MemoryMarshal.Cast<byte, long>(value.Span);
-                    foreach (long item in longPart)
-                    {
-                        hashCode = (hashCode * 397) ^ item.GetHashCode();
-                    }
-
-                    foreach (int item in value.Span.Slice(longPart.Length * 8))
-                    {
-                        hashCode = (hashCode * 397) ^ item.GetHashCode();
-                    }
+                    hashCode = (hashCode * 397) ^ item.GetHashCode();
+                }
 
-                    return hashCode;
+                foreach (int item in value.Span.Slice(longPart.Length * 8))
+                {
+                    hashCode = (hashCode * 397) ^ item.GetHashCode();
                 }
+
+                return hashCode;
+            }
 #else
             HashCode result = default;
             result.AddBytes(value.Span);

projects/Test/Unit/TestAmqpString.cs

@@ -32,6 +32,7 @@
 using System;
 using System.Text;
 using RabbitMQ.Client;
+using RabbitMQ.Util;
 using Xunit;
 
 namespace Test.Unit
@@ -124,5 +125,20 @@ public void TestExchangeName_InitializeFromMemoryIsLazy(string arg)
             Assert.True(e.HasString);
             Assert.Equal(arg, estr);
         }
+
+        [Fact]
+        public void TestEqualityWhenUsingReadOnlyMemoryOfByte()
+        {
+            ReadOnlyMemory<byte> b1 = new byte[] { (byte)'f', (byte)'o', (byte)'o' };
+            ReadOnlyMemory<byte> b2 = new byte[] { (byte)'f', (byte)'o', (byte)'o' };
+
+            Assert.NotEqual(b1.GetHashCode(), b2.GetHashCode());
+            Assert.Equal(ReadOnlyMemoryOfByteEqualityComparer.CalculateHashCode(b1),
+                ReadOnlyMemoryOfByteEqualityComparer.CalculateHashCode(b2));
+
+            var ex1 = new ExchangeName(b1);
+            var ex2 = new ExchangeName(b2);
+            Assert.Equal(ex1, ex2);
+        }
     }
 }