Mapping complex type target members to null when they have no matching source member and no data sources for any child members

Author: SteveWilkes

AgileMapper.UnitTests/Configuration/WhenConfiguringDataSources.cs

@@ -75,6 +75,27 @@ public void ShouldConditionallyApplyAConfiguredConstant()
             }
         }
 
+        [Fact]
+        public void ShouldApplyAConfiguredConstantToANestedMember()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicProperty<string>>()
+                    .To<PublicField<PublicField<PublicField<string>>>>()
+                    .Map("Deep!")
+                    .To(x => x.Value.Value.Value);
+
+                var source = new PublicProperty<string>();
+                var target = new PublicField<PublicField<PublicField<string>>>();
+                var result = mapper.Map(source).Over(target);
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Value.ShouldNotBeNull();
+                result.Value.Value.Value.ShouldNotBeNull("Deep!");
+            }
+        }
+
         [Fact]
         public void ShouldApplyAConfiguredMember()
         {

AgileMapper.UnitTests/Configuration/WhenConfiguringObjectCreationCallbacks.cs

@@ -171,7 +171,7 @@ public void ShouldCallAnObjectCreatedCallbackWithASourceObject()
                 var nonMatchingTarget = new Person { Name = "Fred" };
                 var nonMatchingResult = mapper.Map(nonMatchingSource).OnTo(nonMatchingTarget);
 
-                nonMatchingResult.Address.Line2.ShouldBeNull();
+                nonMatchingResult.Address.ShouldBeNull();
                 nonMatchingResult.Name.ShouldBe("Fred");
 
                 var matchingSource = new PersonViewModel { Name = "Betty" };

AgileMapper.UnitTests/Configuration/WhenIgnoringMembers.cs

@@ -98,23 +98,26 @@ public void ShouldIgnoreMultipleConfiguredMembers()
         {
             using (var mapper = Mapper.CreateNew())
             {
+                var source = new
+                {
+                    Id = Guid.NewGuid().ToString(),
+                    Name = "Bilbo",
+                    AddressLine1 = "House Street",
+                    AddressLine2 = "Town City"
+                };
+
                 mapper.WhenMapping
-                    .From<PersonViewModel>()
+                    .From(source)
                     .ToANew<Person>()
                     .Ignore(p => p.Name, p => p.Address.Line1);
 
-                var source = new PersonViewModel
-                {
-                    Id = Guid.NewGuid(),
-                    Name = "Bilbo",
-                    AddressLine1 = "House Street"
-                };
                 var matchingResult = mapper.Map(source).ToANew<Person>();
 
-                matchingResult.Id.ShouldBe(source.Id);
+                matchingResult.Id.ToString().ShouldBe(source.Id);
                 matchingResult.Name.ShouldBeNull();
                 matchingResult.Address.ShouldNotBeNull();
                 matchingResult.Address.Line1.ShouldBeNull();
+                matchingResult.Address.Line2.ShouldBe("Town City");
             }
         }
 

AgileMapper.UnitTests/WhenMappingOverComplexTypeMembers.cs

@@ -54,6 +54,34 @@ public void ShouldHandleNoMatchingSourceMember()
             result.Address.ShouldNotBeNull();
         }
 
+        // See https://github.com/agileobjects/AgileMapper/issues/21
+        [Fact]
+        public void ShouldNotPopulateAMemberWithNoMatchingSource()
+        {
+            var source = new { Name = "Customer!" };
+            var target = new Customer { Name = "No-one", Address = default(Address) };
+            var result = Mapper.Map(source).Over(target);
+
+            result.Name.ShouldBe("Customer!");
+            result.Address.ShouldBeNull();
+        }
+
+        [Fact]
+        public void ShouldNotOverwriteAMemberWithNoMatchingSource()
+        {
+            var source = new { Name = "Scooby" };
+            var target = new MysteryCustomer
+            {
+                Name = "No-one",
+                Address = new Address { Line1 = "Leave me alone!" }
+            };
+            var originalAddress = target.Address;
+            var result = Mapper.Map(source).Over(target);
+
+            result.Name.ShouldBe("Scooby");
+            result.Address.ShouldBeSameAs(originalAddress);
+        }
+
         [Fact]
         public void ShouldApplyAConfiguredConstant()
         {

AgileMapper.UnitTests/WhenMappingToNewComplexTypeMembers.cs

@@ -42,7 +42,7 @@ public void ShouldHandleNoMatchingSourceMember()
 
             var result = Mapper.Map(source).ToANew<Customer>();
 
-            result.Address.ShouldNotBeNull();
+            result.Address.ShouldBeNull();
         }
 
         [Fact]

AgileMapper/ObjectPopulation/ComplexTypes/ComplexTypeMappingExpressionFactory.cs

@@ -144,11 +144,13 @@ protected override IEnumerable<Expression> GetObjectPopulation(IObjectMappingDat
             }
 
             var assignCreatedObject = postCreationCallback != null;
+            var hasMemberPopulations = MemberPopulationsExist(populationsAndCallbacks);
 
             var instanceVariableValue = TargetObjectResolutionFactory.GetObjectResolution(
                 md => _constructionFactory.GetNewObjectCreation(md),
                 mappingData,
-                assignCreatedObject);
+                assignCreatedObject,
+                hasMemberPopulations: hasMemberPopulations);
 
             var instanceVariableAssignment = mapperData.InstanceVariable.AssignTo(instanceVariableValue);
             yield return instanceVariableAssignment;
@@ -258,6 +260,9 @@ private static void CreateSourceMemberTypeTesterIfRequired(
             mappingData.MapperKey.AddSourceMemberTypeTester(typeTestLambda.Compile());
         }
 
+        private static bool MemberPopulationsExist(IEnumerable<Expression> populationsAndCallbacks)
+            => populationsAndCallbacks.Any(population => population.NodeType != ExpressionType.Constant);
+
         protected override Expression GetReturnValue(ObjectMapperData mapperData) => mapperData.InstanceVariable;
 
         public override void Reset() => _constructionFactory.Reset();

AgileMapper/ObjectPopulation/ComplexTypes/TargetObjectResolutionFactory.cs

@@ -11,7 +11,8 @@ public static Expression GetObjectResolution(
             Func<IObjectMappingData, Expression> constructionFactory,
             IObjectMappingData mappingData,
             bool assignCreatedObject = false,
-            bool assignTargetObject = false)
+            bool assignTargetObject = false,
+            bool hasMemberPopulations = true)
         {
             var mapperData = mappingData.MapperData;
 
@@ -30,6 +31,15 @@ public static Expression GetObjectResolution(
                 return mapperData.TargetObject;
             }
 
+            if (UseNullFallbackValue(mapperData, objectValue, hasMemberPopulations))
+            {
+                objectValue = mapperData.TargetMember.Type.ToDefaultExpression();
+
+                assignCreatedObject =
+                    assignTargetObject =
+                    mapperData.Context.UsesMappingDataObjectAsParameter = false;
+            }
+
             if (assignCreatedObject)
             {
                 mapperData.Context.UsesMappingDataObjectAsParameter = true;
@@ -46,6 +56,23 @@ public static Expression GetObjectResolution(
             return objectValue;
         }
 
+        private static bool UseNullFallbackValue(
+            IMemberMapperData mapperData,
+            Expression objectConstruction,
+            bool hasMemberPopulations)
+        {
+            if (hasMemberPopulations ||
+               (objectConstruction.NodeType != ExpressionType.New) ||
+                mapperData.SourceMember.Matches(mapperData.TargetMember))
+            {
+                return false;
+            }
+
+            var objectNewing = (NewExpression)objectConstruction;
+
+            return objectNewing.Arguments.None();
+        }
+
         private static Expression AddExistingTargetCheckIfAppropriate(Expression value, IObjectMappingData mappingData)
         {
             if (mappingData.MapperData.TargetCouldBePopulated())

AgileMapper/ObjectPopulation/MappingFactory.cs

@@ -196,7 +196,7 @@ public static Expression GetDirectAccessMapping(
             var useLocalSourceValueVariable =
                 ShouldUseLocalSourceValueVariable(mappingValues.SourceValue, mapping, mapperData);
 
-            Expression sourceValue, sourceValueVariableValue = null;
+            Expression sourceValue, sourceValueVariableValue;
 
             if (useLocalSourceValueVariable)
             {
@@ -207,6 +207,7 @@ public static Expression GetDirectAccessMapping(
             else
             {
                 sourceValue = mappingValues.SourceValue;
+                sourceValueVariableValue = null;
             }
 
             var replacementsByTarget = new ExpressionReplacementDictionary

AgileMapper/ObjectPopulation/ObjectMappingData.cs

@@ -75,7 +75,7 @@ private ObjectMappingData(
 
         public IObjectMapper Mapper
         {
-            get { return _mapper ?? (_mapper = MapperContext.ObjectMapperFactory.Create(this)); }
+            get => _mapper ?? (_mapper = MapperContext.ObjectMapperFactory.Create(this));
             set
             {
                 _mapper = (ObjectMapper<TSource, TTarget>)value;