Support creating instances from interfaces of common collections and arrays

Author: mythz

src/ServiceStack.Text/ReflectionExtensions.cs

@@ -88,6 +88,22 @@ public static Type GetGenericType(this Type type)
             return null;
         }
 
+        public static Type GetTypeWithGenericTypeDefinitionOfAny(this Type type, params Type[] genericTypeDefinitions)
+        {
+            foreach (var genericTypeDefinition in genericTypeDefinitions)
+            {
+                var genericType = type.GetTypeWithGenericTypeDefinitionOf(genericTypeDefinition);
+                if (genericType == null && type == genericTypeDefinition)
+                {
+                    genericType = type;
+                }
+
+                if (genericType != null)
+                    return genericType;
+            }
+            return null;
+        }
+
         public static bool IsOrHasGenericInterfaceTypeOf(this Type type, Type genericTypeDefinition)
         {
             return (type.GetTypeWithGenericTypeDefinitionOf(genericTypeDefinition) != null)
@@ -367,6 +383,37 @@ public static EmptyCtorDelegate GetConstructorMethod(string typeName)
 
         public static EmptyCtorDelegate GetConstructorMethodToCache(Type type)
         {
+            if (type.IsInterface)
+            {
+                if (type.HasGenericType())
+                {
+                    var genericType = type.GetTypeWithGenericTypeDefinitionOfAny(
+                        typeof(IDictionary<,>));
+
+                    if (genericType != null)
+                    {
+                        var keyType = genericType.GenericTypeArguments()[0];
+                        var valueType = genericType.GenericTypeArguments()[1];
+                        return GetConstructorMethodToCache(typeof(Dictionary<,>).MakeGenericType(keyType, valueType));
+                    }
+
+                    genericType = type.GetTypeWithGenericTypeDefinitionOfAny(
+                        typeof(IEnumerable<>),
+                        typeof(ICollection<>),
+                        typeof(IList<>));
+
+                    if (genericType != null)
+                    {
+                        var elementType = genericType.GenericTypeArguments()[0];
+                        return GetConstructorMethodToCache(typeof(List<>).MakeGenericType(elementType));
+                    }
+                }
+            }
+            else if (type.IsArray)
+            {
+                return () => Array.CreateInstance(type.GetElementType(), 0);
+            }
+
             var emptyCtor = type.GetEmptyConstructor();
             if (emptyCtor != null)
             {

tests/ServiceStack.Text.Tests/ReflectionExtensionTests.cs

@@ -6,41 +6,41 @@
 
 namespace ServiceStack.Text.Tests
 {
+    public class TestModel
+    {
+        public TestModel()
+        {
+            var i = 0;
+            this.PublicInt = i++;
+            this.PublicGetInt = i++;
+            this.PublicSetInt = i++;
+            this.PublicIntField = i++;
+            this.PrivateInt = i++;
+            this.ProtectedInt = i++;
+        }
+
+        public int PublicInt { get; set; }
+
+        public int PublicGetInt { get; private set; }
+
+        public int PublicSetInt { private get; set; }
+
+        public int PublicIntField;
+
+        private int PrivateInt { get; set; }
+
+        protected int ProtectedInt { get; set; }
+
+        public int IntMethod()
+        {
+            return this.PublicInt;
+        }
+    }
 
 	[TestFixture]
 	public class ReflectionExtensionTests
 		: TestBase
 	{
-		public class TestModel
-		{
-			public TestModel()
-			{
-				var i = 0;
-				this.PublicInt = i++;
-				this.PublicGetInt = i++;
-				this.PublicSetInt = i++;
-				this.PublicIntField = i++;
-				this.PrivateInt = i++;
-				this.ProtectedInt = i++;
-			}
-
-			public int PublicInt { get; set; }
-
-			public int PublicGetInt { get; private set; }
-
-			public int PublicSetInt { private get; set; }
-
-			public int PublicIntField;
-			
-			private int PrivateInt { get; set; }
-			
-			protected int ProtectedInt { get; set; }
-			
-			public int IntMethod()
-			{
-				return this.PublicInt;
-			}
-		}
 
 		[Test]
 		public void Only_serializes_public_readable_properties()
@@ -52,5 +52,16 @@ public void Only_serializes_public_readable_properties()
 
 			Serialize(model);
 		}
-	}
+
+        [Test]
+        public void Can_create_instances_of_common_collections()
+        {
+            Assert.That(typeof(IEnumerable<TestModel>).CreateInstance() as IEnumerable<TestModel>, Is.Not.Null);
+            Assert.That(typeof(ICollection<TestModel>).CreateInstance() as ICollection<TestModel>, Is.Not.Null);
+            Assert.That(typeof(IList<TestModel>).CreateInstance() as IList<TestModel>, Is.Not.Null);
+            Assert.That(typeof(IDictionary<string, TestModel>).CreateInstance() as IDictionary<string, TestModel>, Is.Not.Null);
+            Assert.That(typeof(IDictionary<int, TestModel>).CreateInstance() as IDictionary<int, TestModel>, Is.Not.Null);
+            Assert.That(typeof(TestModel[]).CreateInstance() as TestModel[], Is.Not.Null);
+        }
+    }
 }

tests/ServiceStack.Text.Tests/StructTests.cs

@@ -4,7 +4,6 @@
 using System.Globalization;
 using System.Linq;
 using System.Threading;
-using System.Windows;
 using NUnit.Framework;
 using ServiceStack.Text.Common;
 
@@ -281,4 +280,38 @@ public struct UserStruct
         public int Id { get; set; }
         public string Name { get; set; }
     }
+
+    public struct Rect : IFormattable
+    {
+        double x;
+        double y;
+        double width;
+        double height;
+
+        public Rect(double x, double y, double width, double height)
+        {
+            if (width < 0 || height < 0)
+                throw new ArgumentException("width and height must be non-negative.");
+            this.x = x;
+            this.y = y;
+            this.width = width;
+            this.height = height;
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return "{0},{1},{2},{3}".Fmt(x, y, width, height);
+        }
+
+        public static Rect Parse(string input)
+        {
+            var parts = input.Split(',');
+            return new Rect(
+                double.Parse(parts[0]),
+                double.Parse(parts[1]),
+                double.Parse(parts[2]),
+                double.Parse(parts[3])
+            );
+        }
+    }
 }