Add Dictionary<string,string> to QueuedRedisOperation Pipeline

Author: mythz

lib/ServiceStack.Client.dll

@@ -17,6 +17,7 @@ internal class QueuedRedisOperation
         public Func<byte[][]> MultiBytesReadCommand { get; set; }
         public Func<string> StringReadCommand { get; set; }
         public Func<List<string>> MultiStringReadCommand { get; set; }
+        public Func<Dictionary<string, string>> DictionaryStringReadCommand { get; set; }
         public Func<double> DoubleReadCommand { get; set; }
 
         public Action OnSuccessVoidCallback { get; set; }
@@ -27,6 +28,7 @@ internal class QueuedRedisOperation
         public Action<byte[][]> OnSuccessMultiBytesCallback { get; set; }
         public Action<string> OnSuccessStringCallback { get; set; }
         public Action<List<string>> OnSuccessMultiStringCallback { get; set; }
+        public Action<Dictionary<string, string>> OnSuccessDictionaryStringCallback { get; set; }
         public Action<double> OnSuccessDoubleCallback { get; set; }
 
         public Action<string> OnSuccessTypeCallback { get; set; }
@@ -147,12 +149,14 @@ public void ProcessResult()
                     {
                         OnSuccessMultiStringCallback(result != null ? result.ToStringList() : null);
                     }
-
                     if (OnSuccessMultiTypeCallback != null)
                     {
                         OnSuccessMultiTypeCallback(result.ToStringList());
                     }
-
+                    if (OnSuccessDictionaryStringCallback != null)
+                    {
+                        OnSuccessDictionaryStringCallback(result.ToStringDictionary());
+                    }
                 }
                 else if (MultiStringReadCommand != null)
                 {

lib/ServiceStack.Common.dll

@@ -19,6 +19,7 @@ internal class RedisCommand : QueuedRedisOperation
         public Func<IRedisClient, byte[][]> MultiBytesReturnCommand { get; set; }
         public Func<IRedisClient, string> StringReturnCommand { get; set; }
         public Func<IRedisClient, List<string>> MultiStringReturnCommand { get; set; }
+        public Func<IRedisClient, Dictionary<string, string>> DictionaryStringReturnCommand { get; set; }
         public Func<IRedisClient, double> DoubleReturnCommand { get; set; }
 
         public override void Execute(IRedisClient client)
@@ -63,7 +64,10 @@ public override void Execute(IRedisClient client)
                 else if (MultiStringReturnCommand != null)
                 {
                     MultiStringReturnCommand(client);
-
+                }
+                else if (DictionaryStringReturnCommand != null)
+                {
+                    DictionaryStringReturnCommand(client);
                 }
             }
             catch (Exception ex)

lib/ServiceStack.Interfaces.dll

@@ -224,5 +224,26 @@ public virtual void QueueCommand(Func<IRedisClient, List<string>> command, Actio
             });
             command(RedisClient);
         }
+
+        public void QueueCommand(Func<IRedisClient, Dictionary<string, string>> command)
+        {
+            QueueCommand(command, null, null);
+        }
+
+        public void QueueCommand(Func<IRedisClient, Dictionary<string, string>> command, Action<Dictionary<string, string>> onSuccessCallback)
+        {
+            QueueCommand(command, onSuccessCallback, null);
+        }
+
+        public void QueueCommand(Func<IRedisClient, Dictionary<string, string>> command, Action<Dictionary<string, string>> onSuccessCallback, Action<Exception> onErrorCallback)
+        {
+            BeginQueuedCommand(new QueuedRedisCommand
+            {
+                DictionaryStringReturnCommand = command,
+                OnSuccessDictionaryStringCallback = onSuccessCallback,
+                OnErrorCallback = onErrorCallback
+            });
+            command(RedisClient);
+        }
     }
 }

src/ServiceStack.Redis/Pipeline/QueuedRedisOperation.cs

@@ -126,15 +126,7 @@ public List<string> GetHashValues(string hashId)
 		public Dictionary<string, string> GetAllEntriesFromHash(string hashId)
 		{
 			var multiDataList = base.HGetAll(hashId);
-			var map = new Dictionary<string, string>();
-
-			for (var i = 0; i < multiDataList.Length; i += 2)
-			{
-				var key = multiDataList[i].FromUtf8Bytes();
-				map[key] = multiDataList[i + 1].FromUtf8Bytes();
-			}
-
-			return map;
+            return multiDataList.ToStringDictionary();
 		}
 
 		public List<string> GetValuesFromHash(string hashId, params string[] keys)

src/ServiceStack.Redis/Pipeline/RedisCommand.cs

@@ -143,6 +143,22 @@ public static List<string> ToStringList(this byte[][] multiDataList)
             return results;
         }
 
+        public static Dictionary<string, string> ToStringDictionary(this byte[][] multiDataList)
+        {
+            if (multiDataList == null)
+                return new Dictionary<string, string>();
+
+            var map = new Dictionary<string, string>();
+
+            for (var i = 0; i < multiDataList.Length; i += 2)
+            {
+                var key = multiDataList[i].FromUtf8Bytes();
+                map[key] = multiDataList[i + 1].FromUtf8Bytes();
+            }
+
+            return map;
+        }
+
         private static readonly NumberFormatInfo DoubleFormatProvider = new NumberFormatInfo
         {
             PositiveInfinitySymbol = "+inf",

src/ServiceStack.Redis/Pipeline/RedisCommandQueue.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using NUnit.Framework;
+using ServiceStack.Text;
 
 namespace ServiceStack.Redis.Tests
 {
@@ -12,6 +13,7 @@ public class RedisTransactionTests
         private const string ListKey = "rdtmultitest-list";
         private const string SetKey = "rdtmultitest-set";
         private const string SortedSetKey = "rdtmultitest-sortedset";
+        private const string HashKey = "rdthashtest";
 
         public override void TearDown()
         {
@@ -311,5 +313,24 @@ public void Does_not_set_Expiry_on_existing_key_in_transaction()
             Assert.That(Redis.Get<string>(key), Is.EqualTo("Foo"));
             Assert.That(Redis.GetTimeToLive(key), Is.EqualTo(TimeSpan.MaxValue));
         }
+
+	    [Test]
+        public void Can_call_GetAllEntriesFromHash_in_transaction()
+	    {
+            var stringMap = new Dictionary<string, string> {
+     			{"one","a"}, {"two","b"}, {"three","c"}, {"four","d"}
+     		};
+            stringMap.Each(x => Redis.SetEntryInHash(HashKey, x.Key, x.Value));
+
+            Dictionary<string, string> results = null;
+            using (var trans = Redis.CreateTransaction())
+	        {
+	            trans.QueueCommand(r => r.GetAllEntriesFromHash(HashKey), x => results = x);
+
+	            trans.Commit();
+	        }
+
+            Assert.That(results, Is.EquivalentTo(stringMap));
+        }
     }
 }