Fix exception when deserializing an interface

Fixes #439 Also adds default implementations for the following non-generic collections: - IEnumerable - ICollection - IList - IDictionary
aaubry · Oct 19, 2019 · 2c0ae4c · 2c0ae4c
1 parent 6c1a7b4
commit 2c0ae4c
Show file tree

Hide file tree

Showing 2 changed files with 31 additions and 3 deletions.
diff --git a/YamlDotNet.Test/Serialization/ObjectFactoryTests.cs b/YamlDotNet.Test/Serialization/ObjectFactoryTests.cs
@@ -19,6 +19,7 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
 
+using System.Collections;
 using FluentAssertions;
 using Xunit;
 using YamlDotNet.Serialization.ObjectFactories;
@@ -49,5 +50,13 @@ public void ObjectFactoryIsInvoked()
 
             result.Should().BeOfType<EmptyDerived>();
         }
+
+        [Fact]
+        public void DefaultObjectFactorySupportsNonGenericInterfaces()
+        {
+            var sut = new DefaultObjectFactory();
+            var result = sut.Create(typeof(IList));
+            Assert.IsAssignableFrom<IList>(result);
+        }
     }
 }
diff --git a/YamlDotNet/Serialization/ObjectFactories/DefaultObjectFactory.cs b/YamlDotNet/Serialization/ObjectFactories/DefaultObjectFactory.cs
@@ -20,6 +20,7 @@
 //  SOFTWARE.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 
 namespace YamlDotNet.Serialization.ObjectFactories
@@ -29,21 +30,39 @@ namespace YamlDotNet.Serialization.ObjectFactories
     /// </summary>
     public sealed class DefaultObjectFactory : IObjectFactory
     {
-        private static readonly Dictionary<Type, Type> defaultInterfaceImplementations = new Dictionary<Type, Type>
+        private static readonly Dictionary<Type, Type> defaultGenericInterfaceImplementations = new Dictionary<Type, Type>
         {
             { typeof(IEnumerable<>), typeof(List<>) },
             { typeof(ICollection<>), typeof(List<>) },
             { typeof(IList<>), typeof(List<>) },
             { typeof(IDictionary<,>), typeof(Dictionary<,>) }
         };
 
+        private static readonly Dictionary<Type, Type> defaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
+        {
+            { typeof(IEnumerable), typeof(List<object>) },
+            { typeof(ICollection), typeof(List<object>) },
+            { typeof(IList), typeof(List<object>) },
+            { typeof(IDictionary), typeof(Dictionary<object, object>) }
+        };
+
         public object Create(Type type)
         {
             if (type.IsInterface())
             {
-                if (defaultInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out var implementationType))
+                if (type.IsGenericType())
+                {
+                    if (defaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out var implementationType))
+                    {
+                        type = implementationType.MakeGenericType(type.GetGenericArguments());
+                    }
+                }
+                else
                 {
-                    type = implementationType.MakeGenericType(type.GetGenericArguments());
+                    if (defaultNonGenericInterfaceImplementations.TryGetValue(type, out var implementationType))
+                    {
+                        type = implementationType;
+                    }
                 }
             }