Merge new byte[] key API's into existing code-base

Author: mythz

src/ServiceStack.Redis/RedisClient.KeyByteArray.cs

@@ -154,6 +154,20 @@ public void SetValue(string key, string value)
             base.Set(key, bytesValue);
         }
 
+        public bool SetValue(byte[] key, byte[] value, TimeSpan expireIn)
+        {
+            if (AssertServerVersionNumber() >= 2600)
+            {
+                Exec(r => r.Set(key, value, 0, expiryMs: (long)expireIn.TotalMilliseconds));
+            }
+            else
+            {
+                Exec(r => r.SetEx(key, (int)expireIn.TotalSeconds, value));
+            }
+
+            return true;
+        }
+
         [Obsolete("Use SetValue()")]
         public void SetEntry(string key, string value, TimeSpan expireIn)
         {
@@ -324,6 +338,11 @@ public bool Remove(string key)
             return Del(key) == Success;
         }
 
+        public bool Remove(byte[] key)
+        {
+            return Del(key) == Success;
+        }
+
         public bool RemoveEntry(params string[] keys)
         {
             if (keys.Length == 0) return false;
@@ -394,6 +413,19 @@ public bool ExpireEntryIn(string key, TimeSpan expireIn)
             return Expire(key, (int)expireIn.TotalSeconds);
         }
 
+        public bool ExpireEntryIn(byte[] key, TimeSpan expireIn)
+        {
+            if (AssertServerVersionNumber() >= 2600)
+            {
+                if (expireIn.Milliseconds > 0)
+                {
+                    return PExpire(key, (long)expireIn.TotalMilliseconds);
+                }
+            }
+
+            return Expire(key, (int)expireIn.TotalSeconds);
+        }
+
         public bool ExpireEntryAt(string key, DateTime expireAt)
         {
             if (AssertServerVersionNumber() >= 2600)

src/ServiceStack.Redis/RedisClient.cs

@@ -456,20 +456,26 @@ public void Set(string key, byte[] value)
         }
 
         public void Set(string key, byte[] value, int expirySeconds, long expiryMs = 0)
+        {
+            Set(key.ToUtf8Bytes(), value, expirySeconds, expiryMs);
+        }
+
+        public void Set(byte[] key, byte[] value, int expirySeconds, long expiryMs = 0)
         {
             if (key == null)
                 throw new ArgumentNullException("key");
+
             value = value ?? new byte[0];
 
             if (value.Length > OneGb)
                 throw new ArgumentException("value exceeds 1G", "value");
 
             if (expirySeconds > 0)
-                SendExpectSuccess(Commands.Set, key.ToUtf8Bytes(), value, Commands.Ex, expirySeconds.ToUtf8Bytes());
+                SendExpectSuccess(Commands.Set, key, value, Commands.Ex, expirySeconds.ToUtf8Bytes());
             else if (expiryMs > 0)
-                SendExpectSuccess(Commands.Set, key.ToUtf8Bytes(), value, Commands.Px, expiryMs.ToUtf8Bytes());
+                SendExpectSuccess(Commands.Set, key, value, Commands.Px, expiryMs.ToUtf8Bytes());
             else
-                SendExpectSuccess(Commands.Set, key.ToUtf8Bytes(), value);
+                SendExpectSuccess(Commands.Set, key, value);
         }
 
         public bool Set(string key, byte[] value, bool exists, int expirySeconds = 0, long expiryMs = 0)
@@ -485,6 +491,11 @@ public bool Set(string key, byte[] value, bool exists, int expirySeconds = 0, lo
         }
 
         public void SetEx(string key, int expireInSeconds, byte[] value)
+        {
+            SetEx(key.ToUtf8Bytes(), expireInSeconds, value);
+        }
+
+        public void SetEx(byte[] key, int expireInSeconds, byte[] value)
         {
             if (key == null)
                 throw new ArgumentNullException("key");
@@ -493,7 +504,7 @@ public void SetEx(string key, int expireInSeconds, byte[] value)
             if (value.Length > OneGb)
                 throw new ArgumentException("value exceeds 1G", "value");
 
-            SendExpectSuccess(Commands.SetEx, key.ToUtf8Bytes(), expireInSeconds.ToUtf8Bytes(), value);
+            SendExpectSuccess(Commands.SetEx, key, expireInSeconds.ToUtf8Bytes(), value);
         }
 
         public bool Persist(string key)
@@ -553,6 +564,14 @@ public byte[] Get(string key)
             return GetBytes(key);
         }
 
+        public byte[] Get(byte[] key)
+        {
+            if (key == null)
+                throw new ArgumentNullException("key");
+
+            return SendExpectData(Commands.Get, key);
+        }
+
         public object[] Slowlog(int? top)
         {
             if (top.HasValue)
@@ -596,11 +615,16 @@ public long Exists(string key)
         }
 
         public long Del(string key)
+        {
+            return Del(key.ToUtf8Bytes());
+        }
+
+        public long Del(byte[] key)
         {
             if (key == null)
                 throw new ArgumentNullException("key");
 
-            return SendExpectLong(Commands.Del, key.ToUtf8Bytes());
+            return SendExpectLong(Commands.Del, key);
         }
 
         public long Del(params string[] keys)
@@ -736,19 +760,29 @@ public bool RenameNx(string oldKeyname, string newKeyname)
         }
 
         public bool Expire(string key, int seconds)
+        {
+            return Expire(key.ToUtf8Bytes(), seconds);
+        }
+
+        public bool Expire(byte[] key, int seconds)
         {
             if (key == null)
                 throw new ArgumentNullException("key");
 
-            return SendExpectLong(Commands.Expire, key.ToUtf8Bytes(), seconds.ToUtf8Bytes()) == Success;
+            return SendExpectLong(Commands.Expire, key, seconds.ToUtf8Bytes()) == Success;
         }
 
         public bool PExpire(string key, long ttlMs)
+        {
+            return PExpire(key.ToUtf8Bytes(), ttlMs);
+        }
+
+        public bool PExpire(byte[] key, long ttlMs)
         {
             if (key == null)
                 throw new ArgumentNullException("key");
 
-            return SendExpectLong(Commands.PExpire, key.ToUtf8Bytes(), ttlMs.ToUtf8Bytes()) == Success;
+            return SendExpectLong(Commands.PExpire, key, ttlMs.ToUtf8Bytes()) == Success;
         }
 
         public bool ExpireAt(string key, long unixTime)
@@ -1969,7 +2003,7 @@ public long ZRemRangeByLex(string setId, string min, string max)
 
         #region Hash Operations
 
-        private static void AssertHashIdAndKey(string hashId, byte[] key)
+        private static void AssertHashIdAndKey(object hashId, byte[] key)
         {
             if (hashId == null)
                 throw new ArgumentNullException("hashId");
@@ -1978,10 +2012,15 @@ private static void AssertHashIdAndKey(string hashId, byte[] key)
         }
 
         public long HSet(string hashId, byte[] key, byte[] value)
+        {
+            return HSet(hashId.ToUtf8Bytes(), key, value);
+        }
+
+        public long HSet(byte[] hashId, byte[] key, byte[] value)
         {
             AssertHashIdAndKey(hashId, key);
 
-            return SendExpectLong(Commands.HSet, hashId.ToUtf8Bytes(), key, value);
+            return SendExpectLong(Commands.HSet, hashId, key, value);
         }
 
         public long HSetNX(string hashId, byte[] key, byte[] value)
@@ -2023,10 +2062,15 @@ public double HIncrbyFloat(string hashId, byte[] key, double incrementBy)
         }
 
         public byte[] HGet(string hashId, byte[] key)
+        {
+            return HGet(hashId.ToUtf8Bytes(), key);
+        }
+
+        public byte[] HGet(byte[] hashId, byte[] key)
         {
             AssertHashIdAndKey(hashId, key);
 
-            return SendExpectData(Commands.HGet, hashId.ToUtf8Bytes(), key);
+            return SendExpectData(Commands.HGet, hashId, key);
         }
 
         public byte[][] HMGet(string hashId, params byte[][] keys)
@@ -2042,10 +2086,15 @@ public byte[][] HMGet(string hashId, params byte[][] keys)
         }
 
         public long HDel(string hashId, byte[] key)
+        {
+            return HDel(hashId.ToUtf8Bytes(), key);
+        }
+
+        public long HDel(byte[] hashId, byte[] key)
         {
             AssertHashIdAndKey(hashId, key);
 
-            return SendExpectLong(Commands.HDel, hashId.ToUtf8Bytes(), key);
+            return SendExpectLong(Commands.HDel, hashId, key);
         }
 
         public long HDel(string hashId, byte[][] keys)

src/ServiceStack.Redis/RedisNativeClient.KeyByteArray.cs

@@ -148,8 +148,6 @@
     <Compile Include="BasicRedisClientManager.cs" />
     <Compile Include="BasicRedisClientManager.ICacheClient.cs" />
     <Compile Include="BasicRedisResolver.cs" />
-    <Compile Include="RedisClient.KeyByteArray.cs" />
-    <Compile Include="RedisNativeClient.KeyByteArray.cs" />
     <Compile Include="RedisResolver.cs" />
     <Compile Include="BufferPool.cs" />
     <Compile Include="Commands.cs" />