TryParse

Author: mgravell

src/RESPite/Shared/FrameworkShims.Sequence.cs

@@ -4,9 +4,7 @@ namespace System.Buffers
 {
     internal static class FrameworkSequenceShims
     {
-        // by-value receiver (not 'in'): the returned span references the underlying heap segment, not the
-        // sequence struct, so it must not be scoped to the receiver - matching the BCL FirstSpan semantics
-        extension<T>(ReadOnlySequence<T> sequence)
+        extension<T>(scoped in ReadOnlySequence<T> sequence)
         {
             /// <summary>
             /// Gets the first segment of the sequence as a span. On modern runtimes this is a BCL instance

src/StackExchange.Redis/RedisValue.cs

@@ -284,6 +284,22 @@ internal ReadOnlySequence<byte> RawSequence()
             return default;
         }
 
+        // Linearizes a Sequence payload into the supplied buffer (which must be at least _length long),
+        // walking the segments directly via the iterator - i.e. without paying to build a ReadOnlySequence -
+        // and returns the populated portion of the buffer.
+        private ReadOnlySpan<byte> CopyRawSequence(Span<byte> destination)
+        {
+            var iterator = RawSequenceIterator();
+            int offset = 0;
+            while (iterator.TryNext(out var memory))
+            {
+                memory.Span.CopyTo(destination.Slice(offset));
+                offset += memory.Length;
+            }
+            Debug.Assert(offset == _length, "linearized length mismatch");
+            return destination.Slice(0, offset);
+        }
+
         internal ReadOnlySpan<byte> RawSpan()
         {
             if (_obj is byte[] b) return new ReadOnlySpan<byte>(b, _index, _length);
@@ -1346,6 +1362,15 @@ public bool TryParse(out long val)
                     return Format.TryParseInt64(RawString(), out val);
                 case StorageType.MemoryManager or StorageType.ByteArray:
                     return Format.TryParseInt64(RawSpan(), out val);
+                case StorageType.Sequence:
+                    // longer than the largest possible Int64 text => cannot be an Int64; otherwise
+                    // linearize onto the stack and reuse the span-based parse (matching the ByteArray path)
+                    if (_length <= Format.MaxInt64TextLen)
+                    {
+                        Span<byte> buffer = stackalloc byte[Format.MaxInt64TextLen];
+                        return Format.TryParseInt64(CopyRawSequence(buffer), out val);
+                    }
+                    break;
                 case StorageType.Double:
                     var d = OverlappedValueDouble;
                     try
@@ -1406,6 +1431,15 @@ public bool TryParse(out double val)
                     return Format.TryParseDouble(RawString(), out val);
                 case StorageType.MemoryManager or StorageType.ByteArray:
                     return TryParseDouble(RawSpan(), out val);
+                case StorageType.Sequence:
+                    // longer than the largest possible double text => cannot be a double; otherwise
+                    // linearize onto the stack and reuse the span-based parse (matching the ByteArray path)
+                    if (_length <= Format.MaxDoubleTextLen)
+                    {
+                        Span<byte> buffer = stackalloc byte[Format.MaxDoubleTextLen];
+                        return TryParseDouble(CopyRawSequence(buffer), out val);
+                    }
+                    break;
                 case StorageType.Null:
                     // in redis-land 0 approx. equal null; so roll with it
                     val = 0;

tests/StackExchange.Redis.Tests/RedisValueSequenceTests.cs

@@ -125,6 +125,33 @@ public void IntegerAndTextForms_HashIdentically()
         Assert.Equal(expected, asSequence.GetHashCode());
     }
 
+    [Theory]
+    [InlineData("123")] // integer
+    [InlineData("-123")] // negative integer
+    [InlineData("00")] // leading zeros, within length limit
+    [InlineData("123.5")] // non-integer double
+    [InlineData("-0.25")] // negative double
+    [InlineData("abc")] // not numeric at all
+    [InlineData("12x")] // partially numeric (must not parse)
+    [InlineData("99999999999999999999999")] // oversize: cannot be Int64 or double-as-int
+    public void MultiSegmentSequence_TryParse_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);
+
+        // a sequence-backed value must parse exactly like the equivalent byte[]
+        Assert.Equal(asBytes.TryParse(out long expectedLong), asSequence.TryParse(out long actualLong));
+        Assert.Equal(expectedLong, actualLong);
+
+        Assert.Equal(asBytes.TryParse(out int expectedInt), asSequence.TryParse(out int actualInt));
+        Assert.Equal(expectedInt, actualInt);
+
+        Assert.Equal(asBytes.TryParse(out double expectedDouble), asSequence.TryParse(out double actualDouble));
+        Assert.Equal(expectedDouble, actualDouble);
+    }
+
     [Fact]
     public void MultiSegmentBytes_RoundTripToArray()
     {