Support for supplying the CreateNew mapping result type as a type object, re: issue #66

Author: SteveWilkes

AgileMapper.UnitTests/Dictionaries/WhenMappingToNewDictionaries.cs

@@ -374,6 +374,17 @@ public void ShouldFlattenToValueTypes()
             anonResult["ComplexList[1].Value2.Value"].ShouldBe(789);
         }
 
+        // See https://github.com/agileobjects/AgileMapper/issues/66
+        [Fact]
+        public void ShouldMapToAGivenDictionaryTypeObject()
+        {
+            var source = new PublicProperty<int> { Value = 6473 };
+            var result = Mapper.Map(source).ToANew(typeof(Dictionary<string, string>));
+
+            result.ShouldBeOfType<Dictionary<string, string>>();
+            ((Dictionary<string, string>)result)["Value"].ShouldBe(6473);
+        }
+
         [Fact]
         public void ShouldHandleANullComplexTypeMember()
         {

AgileMapper.UnitTests/Dynamics/WhenMappingToNewDynamics.cs

@@ -43,5 +43,17 @@ public void ShouldMapNestedMembersToAnExpandoObject()
             ((string)result.Address_Line1).ShouldBe("One!");
             ((string)result.Address_Line2).ShouldBe("Two!");
         }
+
+        // See https://github.com/agileobjects/AgileMapper/issues/66
+        [Fact]
+        public void ShouldMapToExpandoObjectIfGivenAsAType()
+        {
+            var source = new PublicProperty<int> { Value = 6473 };
+            var result = Mapper.Map(source).ToANew(typeof(ExpandoObject));
+
+            result.ShouldNotBeNull();
+            dynamic dynamicResult = result;
+            ((int)dynamicResult.Value).ShouldBe(6473);
+        }
     }
 }

AgileMapper.UnitTests/WhenMappingToNewComplexTypes.cs

@@ -85,6 +85,20 @@ public void ShouldMapFromAnInterface()
             result.Value.ShouldBe("Interfaces!");
         }
 
+        // See https://github.com/agileobjects/AgileMapper/issues/66
+        [Fact]
+        public void ShouldMapToAGivenTypeObject()
+        {
+            var source = new PublicProperty<string>
+            {
+                Value = "kjubfelkjnds;lkmm"
+            };
+            var result = Mapper.Map(source).ToANew(typeof(PublicField<string>));
+
+            result.ShouldBeOfType<PublicField<string>>();
+            ((PublicField<string>)result).Value.ShouldBe("kjubfelkjnds;lkmm");
+        }
+
         [Fact]
         public void ShouldHandleAnUnconstructableRootTargetType()
         {

AgileMapper/Api/ITargetSelector.cs

@@ -10,6 +10,13 @@
     /// <typeparam name="TSource">The type of source object from which mapping is being performed.</typeparam>
     public interface ITargetSelector<TSource>
     {
+        /// <summary>
+        /// Create an instance of the given <paramref name="resultType"/> from the specified source object.
+        /// </summary>
+        /// <param name="resultType">The type of object to create from the specified source object.</param>
+        /// <returns>The result of the new object mapping.</returns>
+        object ToANew(Type resultType);
+
         /// <summary>
         /// Create an instance of <typeparamref name="TResult"/> from the specified source object.
         /// </summary>

AgileMapper/MappingExecutor.cs

@@ -5,11 +5,45 @@
     using System.Dynamic;
     using System.Linq;
     using System.Linq.Expressions;
+    using System.Reflection;
     using Api;
     using Api.Configuration;
+    using Caching;
     using Extensions.Internal;
+    using NetStandardPolyfills;
     using ObjectPopulation;
 
+    internal static class MappingExecutorBridge<TSource>
+    {
+        private static readonly ParameterExpression _selectorParameter =
+            Parameters.Create(typeof(ITargetSelector<TSource>));
+
+        private static readonly MethodInfo _typedToANewMethod = typeof(ITargetSelector<TSource>)
+            .GetPublicInstanceMethods("ToANew")
+            .First(m => m.IsGenericMethod && m.GetParameters().None());
+
+        private static readonly ICache<Type, Func<ITargetSelector<TSource>, object>> _createNewCallersByTargetType =
+            GlobalContext.Instance.Cache.CreateScoped<Type, Func<ITargetSelector<TSource>, object>>();
+
+        public static object CreateNew(Type resultType, ITargetSelector<TSource> selector)
+        {
+            var typedCaller = _createNewCallersByTargetType.GetOrAdd(resultType, rt =>
+            {
+                var typedCreateNewCall = Expression.Call(
+                    _selectorParameter,
+                    _typedToANewMethod.MakeGenericMethod(rt));
+
+                var createNewCaller = Expression.Lambda<Func<ITargetSelector<TSource>, object>>(
+                    typedCreateNewCall,
+                    _selectorParameter);
+
+                return createNewCaller.Compile();
+            });
+
+            return typedCaller.Invoke(selector);
+        }
+    }
+
     internal class MappingExecutor<TSource> :
         ITargetSelector<TSource>,
         IFlatteningSelector<TSource>,
@@ -33,6 +67,8 @@ public MappingExecutor(TSource source, MapperContext mapperContext)
 
         #region ToANew Overloads
 
+        public object ToANew(Type resultType) => MappingExecutorBridge<TSource>.CreateNew(resultType, this);
+
         public TResult ToANew<TResult>() => PerformMapping(MapperContext.RuleSets.CreateNew, default(TResult));
 
         public TResult ToANew<TResult>(Expression<Action<IFullMappingInlineConfigurator<TSource, TResult>>> configuration)