fix #946 - reinstante RedisValue.TryParse and add tests

src/StackExchange.Redis/RedisValue.cs

@@ -798,6 +798,84 @@ private RedisValue Simplify()
             return this;
         }
 
+        /// <summary>
+        /// Convert to a long if possible, returning true.
+        ///
+        /// Returns false otherwise.
+        /// </summary>
+        /// <param name="val">The <see cref="long"/> value, if conversion was possible.</param>
+        public bool TryParse(out long val)
+        {
+            switch (Type)
+            {
+                case StorageType.Int64:
+                    val = _overlappedValue64;
+                    return true;
+                case StorageType.String:
+                    return TryParseInt64((string)_objectOrSentinel, out val);
+                case StorageType.Raw:
+                    return TryParseInt64(_memory.Span, out val);
+                case StorageType.Double:
+                    var d = OverlappedValueDouble;
+                    try { val = (long)d; }
+                    catch { val = default;  return false; }
+                    return val == d;
+                case StorageType.Null:
+                    // in redis-land 0 approx. equal null; so roll with it
+                    val = 0;
+                    return true;
+            }
+            val = default;
+            return false;
+        }
+
+        /// <summary>
+        /// Convert to a int if possible, returning true.
+        ///
+        /// Returns false otherwise.
+        /// </summary>
+        /// <param name="val">The <see cref="int"/> value, if conversion was possible.</param>
+        public bool TryParse(out int val)
+        {
+            if (!TryParse(out long l) || l > int.MaxValue || l < int.MinValue)
+            {
+                val = 0;
+                return false;
+            }
+
+            val = (int)l;
+            return true;
+        }
+
+        /// <summary>
+        /// Convert to a double if possible, returning true.
+        ///
+        /// Returns false otherwise.
+        /// </summary>
+        /// <param name="val">The <see cref="double"/> value, if conversion was possible.</param>
+        public bool TryParse(out double val)
+        {
+            switch (Type)
+            {
+                case StorageType.Int64:
+                    val = _overlappedValue64;
+                    return true;
+                case StorageType.Double:
+                    val = OverlappedValueDouble;
+                    return true;
+                case StorageType.String:
+                    return Format.TryParseDouble((string)_objectOrSentinel, out val);
+                case StorageType.Raw:
+                    return TryParseDouble(_memory.Span, out val);
+                case StorageType.Null:
+                    // in redis-land 0 approx. equal null; so roll with it
+                    val = 0;
+                    return true;
+            }
+            val = default;
+            return false;
+        }
+
         /// <summary>
         /// Create a RedisValue from a MemoryStream; it will *attempt* to use the internal buffer
         /// directly, but if this isn't possibly it will fallback to ToArray

tests/StackExchange.Redis.Tests/RedisValueEquivalency.cs

@@ -188,5 +188,95 @@ public void RedisValueStartsWith()
             Assert.True(x.StartsWith(10), LineNumber());
             Assert.False(x.StartsWith(100), LineNumber());
         }
+
+        [Fact]
+        public void TryParseInt64()
+        {
+            Assert.True(((RedisValue)123).TryParse(out long l));
+            Assert.Equal(123, l);
+
+            Assert.True(((RedisValue)123.0).TryParse(out l));
+            Assert.Equal(123, l);
+
+            Assert.True(((RedisValue)(int.MaxValue + 123L)).TryParse(out l));
+            Assert.Equal(int.MaxValue + 123L, l);
+
+            Assert.True(((RedisValue)"123").TryParse(out l));
+            Assert.Equal(123, l);
+
+            Assert.True(((RedisValue)(-123)).TryParse(out l));
+            Assert.Equal(-123, l);
+
+            Assert.True(default(RedisValue).TryParse(out l));
+            Assert.Equal(0, l);
+
+            Assert.True(((RedisValue)123.0).TryParse(out l));
+            Assert.Equal(123, l);
+
+            Assert.False(((RedisValue)"abc").TryParse(out l));
+            Assert.False(((RedisValue)"123.1").TryParse(out l));
+            Assert.False(((RedisValue)123.1).TryParse(out l));
+        }
+
+        [Fact]
+        public void TryParseInt32()
+        {
+            Assert.True(((RedisValue)123).TryParse(out int i));
+            Assert.Equal(123, i);
+
+            Assert.True(((RedisValue)123.0).TryParse(out i));
+            Assert.Equal(123, i);
+
+            Assert.False(((RedisValue)(int.MaxValue + 123L)).TryParse(out i));
+
+            Assert.True(((RedisValue)"123").TryParse(out i));
+            Assert.Equal(123, i);
+
+            Assert.True(((RedisValue)(-123)).TryParse(out i));
+            Assert.Equal(-123, i);
+
+            Assert.True(default(RedisValue).TryParse(out i));
+            Assert.Equal(0, i);
+
+            Assert.True(((RedisValue)123.0).TryParse(out i));
+            Assert.Equal(123, i);
+
+            Assert.False(((RedisValue)"abc").TryParse(out i));
+            Assert.False(((RedisValue)"123.1").TryParse(out i));
+            Assert.False(((RedisValue)123.1).TryParse(out i));
+        }
+
+        [Fact]
+        public void TryParseDouble()
+        {
+            Assert.True(((RedisValue)123).TryParse(out double d));
+            Assert.Equal(123, d);
+
+            Assert.True(((RedisValue)123.0).TryParse(out d));
+            Assert.Equal(123.0, d);
+
+            Assert.True(((RedisValue)123.1).TryParse(out d));
+            Assert.Equal(123.1, d);
+
+            Assert.True(((RedisValue)(int.MaxValue + 123L)).TryParse(out d));
+            Assert.Equal(int.MaxValue + 123L, d);
+
+            Assert.True(((RedisValue)"123").TryParse(out d));
+            Assert.Equal(123.0, d);
+
+            Assert.True(((RedisValue)(-123)).TryParse(out d));
+            Assert.Equal(-123.0, d);
+
+            Assert.True(default(RedisValue).TryParse(out d));
+            Assert.Equal(0.0, d);
+
+            Assert.True(((RedisValue)123.0).TryParse(out d));
+            Assert.Equal(123.0, d);
+
+            Assert.True(((RedisValue)"123.1").TryParse(out d));
+            Assert.Equal(123.1, d);
+
+            Assert.False(((RedisValue)"abc").TryParse(out d));
+        }
     }
 }