polishing

Author: mgravell

src/StackExchange.Redis/RedisValue.cs

@@ -369,19 +369,20 @@ internal string RawString()
                     return false;
             }
 
-            if (xType == StorageType.Sequence &&
-                (yType == StorageType.ByteArray || yType == StorageType.MemoryManager))
-                return x.RawSequence().SequenceEqual(y.RawSpan());
-
-            if (yType == StorageType.Sequence &&
-                (xType == StorageType.ByteArray || xType == StorageType.MemoryManager))
-                return y.RawSequence().SequenceEqual(x.RawSpan());
-
-            if ((xType == StorageType.ByteArray && yType == StorageType.MemoryManager) ||
-                (xType == StorageType.MemoryManager && yType == StorageType.ByteArray))
-                return x.RawSpan().SequenceEqual(y.RawSpan());
+            // both are non-null, non-numeric, and of different kinds; the blob kinds (byte[] / memory /
+            // sequence) compare by bytes in any combination - and we keep the span-vs-span path for the
+            // case where neither side is a multi-segment sequence
+            switch (xType)
+            {
+                case StorageType.Sequence when yType is StorageType.ByteArray or StorageType.MemoryManager:
+                    return x.RawSequence().SequenceEqual(y.RawSpan());
+                case StorageType.ByteArray or StorageType.MemoryManager when yType == StorageType.Sequence:
+                    return y.RawSequence().SequenceEqual(x.RawSpan());
+                case StorageType.ByteArray or StorageType.MemoryManager when yType is StorageType.ByteArray or StorageType.MemoryManager:
+                    return x.RawSpan().SequenceEqual(y.RawSpan());
+            }
 
-            // otherwise, compare as strings
+            // otherwise (anything involving a string), compare as strings
             return (string?)x == (string?)y;
         }
 
@@ -870,6 +871,7 @@ public static explicit operator double(RedisValue value)
                 // special values like NaN/Inf are deliberately not handled by Simplify, but need to be considered for casting
                 StorageType.String when Format.TryParseDouble(value.RawString(), out var d) => d,
                 StorageType.MemoryManager or StorageType.ByteArray when TryParseDouble(value.RawSpan(), out var d) => d,
+                StorageType.Sequence when value.TryParse(out double d) => d, // linearizes + handles inf/nan, like the span case above
                 // anything else: fail
                 _ => throw new InvalidCastException($"Unable to cast from {value.Type} to double: '{value}'"),
             };

tests/StackExchange.Redis.Tests/RedisValueSequenceTests.cs

@@ -206,6 +206,25 @@ public void MultiSegmentSequence_CompareTo_DifferenceAcrossBoundaries()
         Assert.Equal(-expected, Math.Sign(sy.CompareTo(sx))); // antisymmetry
     }
 
+    [Theory]
+    [InlineData("123")] // integer-valued
+    [InlineData("-123")]
+    [InlineData("123.5")] // fractional
+    [InlineData("inf")] // special doubles: deliberately not simplified, so they exercise the cast's text fallback
+    [InlineData("+inf")]
+    [InlineData("-inf")]
+    [InlineData("nan")]
+    public void MultiSegmentSequence_DoubleCast_MatchesByteArray(string text)
+    {
+        var bytes = Encoding.UTF8.GetBytes(text);
+        RedisValue asBytes = bytes; // single-buffer (ByteArray)
+        RedisValue asSequence = SplitEveryByte(bytes); // multi-buffer (Sequence)
+        Assert.Equal(RedisValue.StorageType.Sequence, asSequence.Type);
+
+        // the (double) cast must behave the same for a sequence as for the equivalent byte[]
+        Assert.Equal((double)asBytes, (double)asSequence);
+    }
+
     [Fact]
     public void MultiSegmentBytes_RoundTripToArray()
     {