Add fallback support for IDictionary types like OrderedDictionary

Author: mythz

src/ServiceStack.Text/Common/DeserializeDictionary.cs

@@ -42,6 +42,11 @@ public static ParseStringDelegate GetParseMethod(Type type)
                 {
                     return GetParseMethod(typeof(Dictionary<object, object>));
                 }
+                if (typeof(IDictionary).IsAssignableFromType(type))
+                {
+                    return s => ParseIDictionary(s, type);
+                }
+
                 throw new ArgumentException(string.Format("Type {0} is not of type IDictionary<,>", type.FullName));
             }
 
@@ -122,6 +127,46 @@ public static Dictionary<string, string> ParseStringDictionary(string value)
             return result;
         }
 
+        public static IDictionary ParseIDictionary(string value, Type dictType)
+        {
+            if (value == null) return null;
+
+            var index = VerifyAndGetStartIndex(value, dictType);
+
+            var valueParseMethod = Serializer.GetParseFn(typeof(object));
+            if (valueParseMethod == null) return null;
+
+            var to = (IDictionary)dictType.CreateInstance();
+
+            if (JsonTypeSerializer.IsEmptyMap(value, index)) return to;
+
+            var valueLength = value.Length;
+            while (index < valueLength)
+            {
+                var keyValue = Serializer.EatMapKey(value, ref index);
+                Serializer.EatMapKeySeperator(value, ref index);
+                var elementStartIndex = index;
+                var elementValue = Serializer.EatTypeValue(value, ref index);
+                if (keyValue == null) continue;
+
+                var mapKey = valueParseMethod(keyValue);
+
+                if (elementStartIndex < valueLength)
+                {
+                    Serializer.EatWhitespace(value, ref elementStartIndex);
+                    to[mapKey] = DeserializeType<TSerializer>.ParsePrimitive(elementValue, value[elementStartIndex]);
+                }
+                else
+                {
+                    to[mapKey] = valueParseMethod(elementValue);
+                }
+
+                Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
+            }
+
+            return to;
+        }
+
         public static IDictionary<TKey, TValue> ParseDictionary<TKey, TValue>(
             string value, Type createMapType,
             ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn)

tests/ServiceStack.Text.Tests/DictionaryTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Diagnostics;
 using NUnit.Framework;
 using ServiceStack.Text.Tests.DynamicModels.DataModel;
@@ -500,6 +501,60 @@ public void Nongeneric_implementors_of_IDictionary_K_V_Should_serialize_like_Dic
             IDictionary<string, object> dict = expando;
             Assert.AreEqual(dict.Dump(), new Dictionary<string, object>(dict).Dump());
         }
+
+        [Test]
+        public void Can_serialize_OrderedDictionary()
+        {
+            var dto = new OrderedDictionary { { "A", 1 }, { "B", "2" }, { "C", true } };
+            var to = Serialize(dto, includeXml: false);
+
+            Assert.That(to["A"], Is.EqualTo(1));
+            Assert.That(to["B"], Is.EqualTo("2"));
+            Assert.That(to["C"], Is.EqualTo(true));
+        }
+
+        [Test]
+        public void Can_deserialize_ordereddictionary()
+        {
+            var original = new OrderedDictionary {
+				{"Key1", "Value1"},
+                {"Key2", 2},
+                {3, "Value3"},
+                {"Key4", false}
+          	};
+            var json = JsonSerializer.SerializeToString(original);
+            var deserialized = JsonSerializer.DeserializeFromString<OrderedDictionary>(json);
+
+            json.Print();
+
+            Assert.That(deserialized, Is.Not.Null);
+            Assert.That(deserialized["Key1"], Is.EqualTo("Value1"));
+            Assert.That(deserialized["Key2"], Is.EqualTo(2));
+            Assert.That(deserialized[2], Is.EqualTo("Value3"));
+            Assert.That(deserialized["Key4"], Is.EqualTo(false));
+        }
+
+        [Test]
+        public void Can_deserialize_ordereddictionary_subclass()
+        {
+            var original = new OrderedDictionarySub {
+				{"Key1", "Value1"},
+				{"Key2", 2},
+				{3, "Value3"},
+				{"Key4", false}
+          	};
+            var json = JsonSerializer.SerializeToString(original);
+            var deserialized = JsonSerializer.DeserializeFromString<OrderedDictionarySub>(json);
+
+            json.Print();
+
+            Assert.That(deserialized, Is.Not.Null);
+            Assert.That(deserialized["Key1"], Is.EqualTo("Value1"));
+            Assert.That(deserialized["Key2"], Is.EqualTo(2));
+            Assert.That(deserialized[2], Is.EqualTo("Value3"));
+            Assert.That(deserialized["Key4"], Is.EqualTo(false));
+        }
     }
 
+    public class OrderedDictionarySub : OrderedDictionary {}
 }