- set max len

- use in physicalconnection

Author: mgravell

src/StackExchange.Redis/Format.cs

@@ -399,14 +399,15 @@ internal static unsafe string GetString(ReadOnlySpan<byte> span)
 
         internal const int
             MaxInt32TextLen = 11, // -2,147,483,648 (not including the commas)
-            MaxInt64TextLen = 20; // -9,223,372,036,854,775,808 (not including the commas)
+            MaxInt64TextLen = 20, // -9,223,372,036,854,775,808 (not including the commas),
+            MaxDoubleTextLen = 40; // we use G17, allow for sign/E/and allow plenty of panic room
 
         internal static int MeasureDouble(double value)
         {
             if (double.IsInfinity(value)) return 4; // +inf / -inf
 
 #if NET8_0_OR_GREATER // can use IUtf8Formattable
-            Span<byte> buffer = stackalloc byte[64];
+            Span<byte> buffer = stackalloc byte[MaxDoubleTextLen];
             if (value.TryFormat(buffer, out int len, "G17", NumberFormatInfo.InvariantInfo))
             {
                 return len;

src/StackExchange.Redis/PhysicalConnection.cs

@@ -845,7 +845,9 @@ internal static void WriteBulkString(in RedisValue value, PipeWriter? maybeNullW
                 case RedisValue.StorageType.UInt64:
                     WriteUnifiedUInt64(writer, value.OverlappedValueUInt64);
                     break;
-                case RedisValue.StorageType.Double: // use string
+                case RedisValue.StorageType.Double:
+                    WriteUnifiedDouble(writer, value.OverlappedValueDouble);
+                    break;
                 case RedisValue.StorageType.String:
                     WriteUnifiedPrefixedString(writer, null, (string?)value);
                     break;
@@ -1341,9 +1343,9 @@ private static void WriteUnifiedInt64(PipeWriter writer, long value)
             // note from specification: A client sends to the Redis server a RESP Array consisting of just Bulk Strings.
             // (i.e. we can't just send ":123\r\n", we need to send "$3\r\n123\r\n"
 
-            // ${asc-len}\r\n           = 3 + MaxInt32TextLen
+            // ${asc-len}\r\n           = 4/5 (asc-len at most 2 digits)
             // {asc}\r\n                = MaxInt64TextLen + 2
-            var span = writer.GetSpan(5 + Format.MaxInt32TextLen + Format.MaxInt64TextLen);
+            var span = writer.GetSpan(7 + Format.MaxInt64TextLen);
 
             span[0] = (byte)'$';
             var bytes = WriteRaw(span, value, withLengthPrefix: true, offset: 1);
@@ -1354,20 +1356,40 @@ private static void WriteUnifiedUInt64(PipeWriter writer, ulong value)
         {
             // note from specification: A client sends to the Redis server a RESP Array consisting of just Bulk Strings.
             // (i.e. we can't just send ":123\r\n", we need to send "$3\r\n123\r\n"
-
-            // ${asc-len}\r\n           = 3 + MaxInt32TextLen
-            // {asc}\r\n                = MaxInt64TextLen + 2
-            var span = writer.GetSpan(5 + Format.MaxInt32TextLen + Format.MaxInt64TextLen);
-
             Span<byte> valueSpan = stackalloc byte[Format.MaxInt64TextLen];
+
             var len = Format.FormatUInt64(value, valueSpan);
+            // ${asc-len}\r\n           = 4/5 (asc-len at most 2 digits)
+            // {asc}\r\n                = {len} + 2
+            var span = writer.GetSpan(7 + len);
             span[0] = (byte)'$';
             int offset = WriteRaw(span, len, withLengthPrefix: false, offset: 1);
             valueSpan.Slice(0, len).CopyTo(span.Slice(offset));
             offset += len;
             offset = WriteCrlf(span, offset);
             writer.Advance(offset);
         }
+
+        private static void WriteUnifiedDouble(PipeWriter writer, double value)
+        {
+#if NET8_0_OR_GREATER
+            Span<byte> valueSpan = stackalloc byte[Format.MaxDoubleTextLen];
+            var len = Format.FormatDouble(value, valueSpan);
+
+            // ${asc-len}\r\n           = 4/5 (asc-len at most 2 digits)
+            // {asc}\r\n                = {len} + 2
+            var span = writer.GetSpan(7 + len);
+            span[0] = (byte)'$';
+            int offset = WriteRaw(span, len, withLengthPrefix: false, offset: 1);
+            offset += len;
+            offset = WriteCrlf(span, offset);
+            writer.Advance(offset);
+#else
+            // fallback: drop to string
+            WriteUnifiedPrefixedString(writer, null, Format.ToString(value));
+#endif
+        }
+
         internal static void WriteInteger(PipeWriter writer, long value)
         {
             // note: client should never write integer; only server does this

src/StackExchange.Redis/RedisValue.cs

@@ -149,7 +149,7 @@ public bool IsNullOrEmpty
         /// <param name="y">The second <see cref="RedisValue"/> to compare.</param>
         public static bool operator !=(RedisValue x, RedisValue y) => !(x == y);
 
-        private double OverlappedValueDouble
+        internal double OverlappedValueDouble
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get => BitConverter.Int64BitsToDouble(_overlappedBits64);
@@ -849,7 +849,7 @@ private static string ToHex(ReadOnlySpan<byte> src)
                     len = Format.FormatUInt64(value.OverlappedValueUInt64, span);
                     return span.Slice(0, len).ToArray();
                 case StorageType.Double:
-                    span = stackalloc byte[128];
+                    span = stackalloc byte[Format.MaxDoubleTextLen];
                     len = Format.FormatDouble(value.OverlappedValueDouble, span);
                     return span.Slice(0, len).ToArray();
                 case StorageType.String: