Support for mapping between runtime-typed simple types in object enumerables

Author: SteveWilkes

AgileMapper.Net40/AgileMapper.Net40.csproj

@@ -780,6 +780,7 @@
     <Compile Include="..\VersionInfo.cs">
       <Link>Properties\VersionInfo.cs</Link>
     </Compile>
+    <Compile Include="ObjectPopulation\SimpleTypeMappingExpressionFactory.cs" />
     <Compile Include="Properties\AssemblyInfo.Net40.cs" />
   </ItemGroup>
   <ItemGroup>

AgileMapper.Net40/ObjectPopulation/SimpleTypeMappingExpressionFactory.cs

@@ -0,0 +1,42 @@
+namespace AgileObjects.AgileMapper.ObjectPopulation
+{
+    using System.Collections.Generic;
+    using System.Linq.Expressions;
+    using Extensions;
+    using Members;
+
+    internal class SimpleTypeMappingExpressionFactory : MappingExpressionFactoryBase
+    {
+        public override bool IsFor(IObjectMappingData mappingData)
+        {
+            return mappingData.MapperKey.MappingTypes.TargetType.IsSimple();
+        }
+
+        protected override bool TargetCannotBeMapped(IObjectMappingData mappingData, out Expression nullMappingBlock)
+        {
+            nullMappingBlock = null;
+            return false;
+        }
+
+        protected override IEnumerable<Expression> GetShortCircuitReturns(GotoExpression returnNull, IObjectMappingData mappingData)
+            => Enumerable<Expression>.Empty;
+
+        protected override Expression GetDerivedTypeMappings(IObjectMappingData mappingData)
+            => Constants.EmptyExpression;
+
+        protected override IEnumerable<Expression> GetObjectPopulation(IObjectMappingData mappingData)
+        {
+            var mapperData = mappingData.MapperData;
+
+            if (mapperData.MapperContext.ValueConverters.CanConvert(mapperData.SourceType, mapperData.TargetType))
+            {
+                yield return mapperData.GetValueConversion(mapperData.SourceObject, mapperData.TargetType);
+                yield break;
+            }
+
+            yield return mapperData.TargetObject;
+        }
+
+        protected override Expression GetReturnValue(ObjectMapperData mapperData) => mapperData.InstanceVariable;
+    }
+}

AgileMapper.UnitTests/WhenMappingToNewEnumerableMembers.cs

@@ -42,6 +42,22 @@ public void ShouldCreateANewIntEnumerable()
             result.Value.SequenceEqual(source.Value).ShouldBeTrue();
         }
 
+        [Fact]
+        public void ShouldCreateANewObjectCollection()
+        {
+            var source = new PublicField<object[]>
+            {
+                Value = new object[] { 9, new Person { Name = "Mags" }, string.Empty }
+            };
+            var result = Mapper.Map(source).ToANew<PublicField<Collection<object>>>();
+
+            result.Value.ShouldNotBeNull();
+            result.Value.First().ShouldBe(9);
+            result.Value.Second().ShouldBeOfType<Person>();
+            ((Person)result.Value.Second()).Name.ShouldBe("Mags");
+            result.Value.Third().ShouldBe(string.Empty);
+        }
+
         [Fact]
         public void ShouldCreateANewComplexTypeEnumerable()
         {
@@ -221,16 +237,6 @@ public void ShouldHandleANullSourceMemberForAWriteOnlyTarget()
             result.Value.ShouldBeEmpty();
         }
 
-        [Fact]
-        public void ShouldCreateAnEmptyCollectionByDefault()
-        {
-            var source = new PublicProperty<Collection<int>> { Value = null };
-            var result = Mapper.Map(source).ToANew<PublicProperty<Collection<int>>>();
-
-            result.Value.ShouldNotBeNull();
-            result.Value.ShouldBeEmpty();
-        }
-
         [Fact]
         public void ShouldPopulateANonNullReadOnlyNestedICollection()
         {
@@ -337,6 +343,16 @@ public void ShouldPopulateANonNullReadOnlyNestedIList()
             }
         }
 
+        [Fact]
+        public void ShouldCreateAnEmptyCollectionByDefault()
+        {
+            var source = new PublicProperty<Collection<int>> { Value = null };
+            var result = Mapper.Map(source).ToANew<PublicProperty<Collection<int>>>();
+
+            result.Value.ShouldNotBeNull();
+            result.Value.ShouldBeEmpty();
+        }
+
         [Fact]
         public void ShouldMapCollectionsToNullIfConfiguredGlobally()
         {

AgileMapper/ObjectPopulation/MappingExpressionFactoryBase.cs

@@ -88,6 +88,11 @@ private Expression GetMappingBlock(IList<Expression> mappingExpressions, ObjectM
         {
             if (mappingExpressions[0].NodeType != ExpressionType.Block)
             {
+                if (mappingExpressions[0].NodeType == ExpressionType.MemberAccess)
+                {
+                    return mappingExpressions[0];
+                }
+
                 var objectAssignment = mappingExpressions.First(exp => exp.NodeType == ExpressionType.Assign);
 
                 if (mappingExpressions.Last() == objectAssignment)

AgileMapper/ObjectPopulation/ObjectMapperFactory.cs

@@ -17,6 +17,7 @@ public ObjectMapperFactory(MapperContext mapperContext)
             _mappingExpressionFactories = new MappingExpressionFactoryBase[]
             {
                 new DictionaryMappingExpressionFactory(),
+                new SimpleTypeMappingExpressionFactory(),
                 new EnumerableMappingExpressionFactory(),
                 new ComplexTypeMappingExpressionFactory(mapperContext)
             };

AgileMapper/ObjectPopulation/ObjectMappingDataFactory.cs

@@ -355,10 +355,14 @@ private static MappingDataCreator<TSource, TTarget> GetMappingDataCreator<TSourc
                 var sourceParameter = Parameters.Create(k.DeclaredSourceType, "source");
                 var targetParameter = Parameters.Create(k.DeclaredTargetType, "target");
 
+                var targetParameterValue = k.RuntimeTargetType.IsPrimitive()
+                    ? Expression.Coalesce(targetParameter, typeof(int).ToDefaultExpression())
+                    : (Expression)targetParameter;
+
                 var constructorCall = Expression.New(
                     dataType.GetPublicInstanceConstructors().First(),
                     sourceParameter.GetConversionTo(k.RuntimeSourceType),
-                    targetParameter.GetConversionTo(k.RuntimeTargetType),
+                    targetParameterValue.GetConversionTo(k.RuntimeTargetType),
                     enumerableIndexParameter,
                     mapperKeyParameter,
                     Parameters.MappingContext,