implement IConvertible

StackExchange.Redis.Tests/KeysAndValues.cs

@@ -4,6 +4,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using System.Globalization;
 
 namespace StackExchange.Redis.Tests
 {
@@ -113,5 +114,39 @@ private void CheckNull(RedisValue value)
             CheckSame(value, (string)null);
             CheckSame(value, (byte[])null);
         }
+
+
+        [Test]
+        public void ValuesAreConvertible()
+        {
+            RedisValue val = 123;
+            object o = val;
+            byte[] blob = (byte[])Convert.ChangeType(o, typeof(byte[]));
+
+            Assert.AreEqual(3, blob.Length);
+            Assert.AreEqual((byte)'1', blob[0]);
+            Assert.AreEqual((byte)'2', blob[1]);
+            Assert.AreEqual((byte)'3', blob[2]);
+
+            Assert.AreEqual((double)123, Convert.ToDouble(o));
+
+            IConvertible c = (IConvertible)o;
+            Assert.AreEqual((short)123, c.ToInt16(CultureInfo.InvariantCulture));
+            Assert.AreEqual((int)123, c.ToInt32(CultureInfo.InvariantCulture));
+            Assert.AreEqual((long)123, c.ToInt64(CultureInfo.InvariantCulture));
+            Assert.AreEqual((float)123, c.ToSingle(CultureInfo.InvariantCulture));
+            Assert.AreEqual("123", c.ToString(CultureInfo.InvariantCulture));
+            Assert.AreEqual((double)123, c.ToDouble(CultureInfo.InvariantCulture));
+            Assert.AreEqual((decimal)123, c.ToDecimal(CultureInfo.InvariantCulture));
+            Assert.AreEqual((ushort)123, c.ToUInt16(CultureInfo.InvariantCulture));
+            Assert.AreEqual((uint)123, c.ToUInt32(CultureInfo.InvariantCulture));
+            Assert.AreEqual((ulong)123, c.ToUInt64(CultureInfo.InvariantCulture));
+
+            blob = (byte[])c.ToType(typeof(byte[]), CultureInfo.InvariantCulture);
+            Assert.AreEqual(3, blob.Length);
+            Assert.AreEqual((byte)'1', blob[0]);
+            Assert.AreEqual((byte)'2', blob[1]);
+            Assert.AreEqual((byte)'3', blob[2]);
+        }
     }
 }

StackExchange.Redis/StackExchange/Redis/RedisValue.cs

@@ -6,7 +6,7 @@ namespace StackExchange.Redis
     /// <summary>
     /// Represents values that can be stored in redis
     /// </summary>
-    public struct RedisValue : IEquatable<RedisValue>, IComparable<RedisValue>, IComparable
+    public struct RedisValue : IEquatable<RedisValue>, IComparable<RedisValue>, IComparable, IConvertible
     {
         internal static readonly RedisValue[] EmptyArray = new RedisValue[0];
 
@@ -530,5 +530,112 @@ static bool TryParseDouble(byte[] blob, out double value)
             }
             return valueBlob;
         }
+
+        TypeCode IConvertible.GetTypeCode()
+        {
+            return TypeCode.Object;
+        }
+
+        bool IConvertible.ToBoolean(IFormatProvider provider)
+        {
+            return (bool)this;
+        }
+
+        byte IConvertible.ToByte(IFormatProvider provider)
+        {
+            return (byte)this;
+        }
+
+        char IConvertible.ToChar(IFormatProvider provider)
+        {
+            return (char)this;
+        }
+
+        DateTime IConvertible.ToDateTime(IFormatProvider provider)
+        {
+            return DateTime.Parse((string)this, provider);
+        }
+
+        decimal IConvertible.ToDecimal(IFormatProvider provider)
+        {
+            return (decimal)this;
+        }
+
+        double IConvertible.ToDouble(IFormatProvider provider)
+        {
+            return (double)this;
+        }
+
+        short IConvertible.ToInt16(IFormatProvider provider)
+        {
+            return (short)this;
+        }
+
+        int IConvertible.ToInt32(IFormatProvider provider)
+        {
+            return (int)this;
+        }
+
+        long IConvertible.ToInt64(IFormatProvider provider)
+        {
+            return (long)this;
+        }
+
+        sbyte IConvertible.ToSByte(IFormatProvider provider)
+        {
+            return (sbyte)this;
+        }
+
+        float IConvertible.ToSingle(IFormatProvider provider)
+        {
+            return (float)this;
+        }
+
+        string IConvertible.ToString(IFormatProvider provider)
+        {
+            return (string)this;
+        }
+
+        object IConvertible.ToType(Type conversionType, IFormatProvider provider)
+        {
+            if (conversionType== null) throw new ArgumentNullException("conversionType");
+            if (conversionType== typeof(byte[])) return (byte[])this;
+            if (conversionType == typeof(RedisValue)) return this;
+            switch(Type.GetTypeCode(conversionType))
+            {
+                case TypeCode.Boolean: return (bool)this;
+                case TypeCode.Byte: return (byte)this;
+                case TypeCode.Char: return (char)this;
+                case TypeCode.DateTime: return DateTime.Parse((string)this, provider);
+                case TypeCode.Decimal: return (decimal)this;
+                case TypeCode.Double: return (double)this;
+                case TypeCode.Int16: return (short)this;
+                case TypeCode.Int32: return (int)this;
+                case TypeCode.Int64: return (long)this;
+                case TypeCode.SByte: return (sbyte)this;
+                case TypeCode.Single: return (float)this;
+                case TypeCode.String: return (string)this;
+                case TypeCode.UInt16: return (ushort)this;
+                case TypeCode.UInt32: return (uint)this;
+                case TypeCode.UInt64: return (long)this;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        ushort IConvertible.ToUInt16(IFormatProvider provider)
+        {
+            return (ushort)this;
+        }
+
+        uint IConvertible.ToUInt32(IFormatProvider provider)
+        {
+            return (uint)this;
+        }
+
+        ulong IConvertible.ToUInt64(IFormatProvider provider)
+        {
+            return (ulong)this;
+        }
     }
 }