Removed abstract method AddTypeMapping from BuilderSkeleton as this o…

…nly applies to DeserializerBuilder.

Updated dictionaries to instance types as the static types caused concurrent unit tests to fail.
Updated DefaultObjectFactory to use lazy loading to allow constructor initialization with type mappings.

YamlDotNet.Test/Serialization/DeserializerTest.cs

@@ -0,0 +1,131 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System.Collections.Generic;
+using FluentAssertions;
+using Xunit;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace YamlDotNet.Test.Serialization
+{
+    public class DeserializerTest
+    {
+        [Fact]
+        public void Deserialize_YamlWithInterfaceTypeAndMapping_ReturnsModel()
+        {
+            var yaml = @"
+name: Jack
+cars:
+- name: Mercedes
+  year: 2018
+- name: Honda
+  year: 2021
+";
+
+            var sut = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeMapping<ICar, Car>()
+                .Build();
+
+            var person = sut.Deserialize<Person>(yaml);
+            person.Name.Should().Be("Jack");
+            person.Cars.Should().HaveCount(2);
+            person.Cars[0].Name.Should().Be("Mercedes");
+            person.Cars[0].Spec.Should().BeNull();
+            person.Cars[1].Name.Should().Be("Honda");
+            person.Cars[1].Spec.Should().BeNull();
+        }
+
+        [Fact]
+        public void Deserialize_YamlWithTwoInterfaceTypesAndMappings_ReturnsModel()
+        {
+            var yaml = @"
+name: Jack
+cars:
+- name: Mercedes
+  year: 2018
+  spec:
+    engineType: V6
+    driveType: AWD
+- name: Honda
+  year: 2021
+  spec:
+    engineType: V4
+    driveType: FWD
+";
+
+            var sut = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeMapping<ICar, Car>()
+                .WithTypeMapping<IModelSpec, ModelSpec>()
+                .Build();
+
+            var person = sut.Deserialize<Person>(yaml);
+            person.Name.Should().Be("Jack");
+            person.Cars.Should().HaveCount(2);
+            person.Cars[0].Name.Should().Be("Mercedes");
+            person.Cars[0].Spec.EngineType.Should().Be("V6");
+            person.Cars[0].Spec.DriveType.Should().Be("AWD");
+            person.Cars[1].Name.Should().Be("Honda");
+            person.Cars[1].Spec.EngineType.Should().Be("V4");
+            person.Cars[1].Spec.DriveType.Should().Be("FWD");
+        }
+
+        public class Person
+        {
+            public string Name { get; private set; }
+
+            public IList<ICar> Cars { get; private set; }
+        }
+
+        public class Car : ICar
+        {
+            public string Name { get; private set; }
+
+            public int Year { get; private set; }
+
+            public IModelSpec Spec { get; private set; }
+        }
+
+        public interface ICar
+        {
+            string Name { get; }
+
+            int Year { get; }
+            IModelSpec Spec { get; }
+        }
+
+        public class ModelSpec : IModelSpec
+        {
+            public string EngineType { get; private set; }
+
+            public string DriveType { get; private set; }
+        }
+
+        public interface IModelSpec
+        {
+            string EngineType { get; }
+
+            string DriveType { get; }
+        }
+    }
+}

YamlDotNet/Helpers/Portability/net20+net35+unitysubset3.5/Lazy.cs

@@ -41,6 +41,13 @@ public Lazy(T value)
             valueState = ValueState.Created;
         }
 
+        public Lazy(Func<T> valueFactory)
+        {
+            this.valueFactory = valueFactory;
+            this.isThreadSafe = false;
+            valueState = ValueState.NotCreated;
+        }
+
         public Lazy(Func<T> valueFactory, bool isThreadSafe)
         {
             this.valueFactory = valueFactory;

YamlDotNet/Serialization/BuilderSkeleton.cs

@@ -111,9 +111,6 @@ public TBuilder WithTypeResolver(ITypeResolver typeResolver)
 
         public abstract TBuilder WithTagMapping(TagName tag, Type type);
 
-        public abstract TBuilder WithTypeMapping<TInterface, TConcrete>()
-            where TConcrete : TInterface;
-
 #if !NET20
         /// <summary>
         /// Register an <see cref="Attribute"/> for a given property.

YamlDotNet/Serialization/DeserializerBuilder.cs

@@ -41,11 +41,11 @@ namespace YamlDotNet.Serialization
     /// </summary>
     public sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
     {
-        private IObjectFactory objectFactory = new DefaultObjectFactory();
+        private Lazy<IObjectFactory> objectFactory;
         private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;
         private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;
         private readonly Dictionary<TagName, Type> tagMappings;
-        private readonly Dictionary<Type, Type> typeMappings = new Dictionary<Type, Type>();
+        private readonly Dictionary<Type, Type> typeMappings;
         private bool ignoreUnmatched;
 
         /// <summary>
@@ -54,6 +54,9 @@ public sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
         public DeserializerBuilder()
             : base(new StaticTypeResolver())
         {
+            typeMappings = new Dictionary<Type, Type>();
+            objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings), true);
+
             tagMappings = new Dictionary<TagName, Type>
             {
                 { FailsafeSchema.Tags.Map, typeof(Dictionary<object, object>) },
@@ -72,16 +75,16 @@ public DeserializerBuilder()
 
             nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
             {
-                { typeof(YamlConvertibleNodeDeserializer), _ => new YamlConvertibleNodeDeserializer(objectFactory) },
-                { typeof(YamlSerializableNodeDeserializer), _ => new YamlSerializableNodeDeserializer(objectFactory) },
+                { typeof(YamlConvertibleNodeDeserializer), _ => new YamlConvertibleNodeDeserializer(objectFactory.Value) },
+                { typeof(YamlSerializableNodeDeserializer), _ => new YamlSerializableNodeDeserializer(objectFactory.Value) },
                 { typeof(TypeConverterNodeDeserializer), _ => new TypeConverterNodeDeserializer(BuildTypeConverters()) },
                 { typeof(NullNodeDeserializer), _ => new NullNodeDeserializer() },
                 { typeof(ScalarNodeDeserializer), _ => new ScalarNodeDeserializer() },
                 { typeof(ArrayNodeDeserializer), _ => new ArrayNodeDeserializer() },
-                { typeof(DictionaryNodeDeserializer), _ => new DictionaryNodeDeserializer(objectFactory) },
-                { typeof(CollectionNodeDeserializer), _ => new CollectionNodeDeserializer(objectFactory) },
+                { typeof(DictionaryNodeDeserializer), _ => new DictionaryNodeDeserializer(objectFactory.Value) },
+                { typeof(CollectionNodeDeserializer), _ => new CollectionNodeDeserializer(objectFactory.Value) },
                 { typeof(EnumerableNodeDeserializer), _ => new EnumerableNodeDeserializer() },
-                { typeof(ObjectNodeDeserializer), _ => new ObjectNodeDeserializer(objectFactory, BuildTypeInspector(), ignoreUnmatched) }
+                { typeof(ObjectNodeDeserializer), _ => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched) }
             };
 
             nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
@@ -102,7 +105,12 @@ public DeserializerBuilder()
         /// </summary>
         public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
         {
-            this.objectFactory = objectFactory ?? throw new ArgumentNullException(nameof(objectFactory));
+            if (objectFactory == null)
+            {
+                throw new ArgumentNullException(nameof(objectFactory));
+            }
+
+            this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory, true);
             return this;
         }
 
@@ -304,9 +312,10 @@ public override DeserializerBuilder WithTagMapping(TagName tag, Type type)
         }
 
         /// <summary>
-        /// Registers a type mapping.
+        /// Registers a type mapping using the default object factory.
         /// </summary>
-        public override DeserializerBuilder WithTypeMapping<TInterface, TConcrete>()
+        public DeserializerBuilder WithTypeMapping<TInterface, TConcrete>()
+            where TConcrete : TInterface
         {
             var interfaceType = typeof(TInterface);
             var concreteType = typeof(TConcrete);
@@ -359,7 +368,6 @@ public DeserializerBuilder IgnoreUnmatchedProperties()
         /// </summary>
         public IDeserializer Build()
         {
-            objectFactory = new DefaultObjectFactory(typeMappings);
             return Deserializer.FromValueDeserializer(BuildValueDeserializer());
         }
 

YamlDotNet/Serialization/ObjectFactories/DefaultObjectFactory.cs

@@ -30,15 +30,15 @@ namespace YamlDotNet.Serialization.ObjectFactories
     /// </summary>
     public sealed class DefaultObjectFactory : IObjectFactory
     {
-        private static readonly Dictionary<Type, Type> DefaultGenericInterfaceImplementations = new Dictionary<Type, Type>
+        private 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>
+        private readonly Dictionary<Type, Type> DefaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
         {
             { typeof(IEnumerable), typeof(List<object>) },
             { typeof(ICollection), typeof(List<object>) },
@@ -54,7 +54,7 @@ public DefaultObjectFactory(IDictionary<Type, Type> mappings)
         {
             foreach (var pair in mappings)
             {
-				if (!pair.Key.IsAssignableFrom(pair.Value))
+                if (!pair.Key.IsAssignableFrom(pair.Value))
                 {
                     throw new InvalidOperationException($"Type '{pair.Value}' does not implement type '{pair.Key}'.");
                 }

YamlDotNet/Serialization/SerializerBuilder.cs

@@ -543,11 +543,6 @@ public IValueSerializer BuildValueSerializer()
             );
         }
 
-        public override SerializerBuilder WithTypeMapping<TInterface, TConcrete>()
-        {
-            throw new NotImplementedException("This is only used by the deserializer");
-        }
-
         private class ValueSerializer : IValueSerializer
         {
             private readonly IObjectGraphTraversalStrategy traversalStrategy;