Support for 'fallback' derived type mapping when conditional derived type pairs don't match and target type is set by source type

Author: SteveWilkes

AgileMapper.UnitTests/WhenMappingDerivedTypes.cs

@@ -132,14 +132,22 @@ public void ShouldConditionallyMapDerivedTypesFromNestedMembers()
                     .If((s, t) => s.Name == "Customer Mystery!")
                     .MapTo<MysteryCustomerViewModel>();
 
-                var personSource = new PublicField<PersonViewModel>
+                var mysteryCustomerSource = new PublicField<PersonViewModel>
                 {
                     Value = new CustomerViewModel { Name = "Mystery Customer", Discount = 0.5 }
                 };
-                var result = mapper.Map(personSource).ToANew<PublicProperty<PersonViewModel>>();
+                var result = mapper.Map(mysteryCustomerSource).ToANew<PublicProperty<PersonViewModel>>();
 
                 result.Value.ShouldBeOfType<MysteryCustomerViewModel>();
                 ((MysteryCustomerViewModel)result.Value).Discount.ShouldBe(0.5);
+
+                var customerSource = new PublicField<PersonViewModel>
+                {
+                    Value = new CustomerViewModel { Name = "Banksy" }
+                };
+                result = mapper.Map(customerSource).ToANew<PublicProperty<PersonViewModel>>();
+
+                result.Value.ShouldBeOfType<CustomerViewModel>();
             }
         }
     }

AgileMapper/Extensions/ExpressionExtensions.cs

@@ -65,10 +65,10 @@ public static Expression GetIsNotDefaultComparisonsOrNull(this IEnumerable<Expre
             return allNotNullCheck;
         }
 
-        public static BinaryExpression GetIsDefaultComparison(this Expression expression)
+        public static Expression GetIsDefaultComparison(this Expression expression)
             => Expression.Equal(expression, Expression.Default(expression.Type));
 
-        public static BinaryExpression GetIsNotDefaultComparison(this Expression expression)
+        public static Expression GetIsNotDefaultComparison(this Expression expression)
             => Expression.NotEqual(expression, Expression.Default(expression.Type));
 
         public static Expression GetToValueOrDefaultCall(this Expression nullableExpression)

AgileMapper/ObjectPopulation/DerivedComplexTypeMappingsFactory.cs

@@ -113,7 +113,7 @@ private static void AddDerivedSourceTypeMappings(
             IEnumerable<Type> derivedSourceTypes,
             IObjectMappingData declaredTypeMappingData,
             ICollection<ParameterExpression> typedObjectVariables,
-            ICollection<Expression> typeTests)
+            ICollection<Expression> derivedTypeMappings)
         {
             var declaredTypeMapperData = declaredTypeMappingData.MapperData;
 
@@ -124,41 +124,83 @@ private static void AddDerivedSourceTypeMappings(
                 var typeAsConversion = Expression.TypeAs(declaredTypeMapperData.SourceObject, derivedSourceType);
                 var typedVariableAssignment = Expression.Assign(typedVariable, typeAsConversion);
 
+                typedObjectVariables.Add(typedVariable);
+                derivedTypeMappings.Add(typedVariableAssignment);
+
                 var targetType = declaredTypeMapperData.TargetType.GetRuntimeTargetType(derivedSourceType);
 
-                var condition = GetTypePairCondition(typedVariable, derivedSourceType, ref targetType, declaredTypeMapperData);
+                var condition = typedVariable.GetIsNotDefaultComparison();
+                condition = AppendTargetValidCheckIfAppropriate(condition, targetType, declaredTypeMapperData);
 
-                var mapping = MappingFactory
-                    .GetDerivedTypeMapping(declaredTypeMappingData, typedVariable, targetType);
+                var derivedTypePairs = GetTypePairsFor(derivedSourceType, targetType, declaredTypeMapperData);
+                Expression ifTypePairsConditionThenMap, ifSourceVariableIsDerivedTypeThenMap;
 
-                var returnMappingResult = Expression.Return(declaredTypeMapperData.ReturnLabelTarget, mapping);
-                var ifConditionThenMap = Expression.IfThen(condition, returnMappingResult);
+                if (derivedTypePairs.None())
+                {
+                    ifSourceVariableIsDerivedTypeThenMap = GetIfConditionThenMapExpression(
+                        declaredTypeMappingData,
+                        condition,
+                        typedVariable,
+                        targetType);
+
+                    derivedTypeMappings.Add(ifSourceVariableIsDerivedTypeThenMap);
+                    continue;
+                }
 
-                typedObjectVariables.Add(typedVariable);
-                typeTests.Add(typedVariableAssignment);
-                typeTests.Add(ifConditionThenMap);
+                if (derivedTypePairs.All(tp => !tp.HasConfiguredCondition))
+                {
+                    ifSourceVariableIsDerivedTypeThenMap = GetIfConditionThenMapExpression(
+                        declaredTypeMappingData,
+                        condition,
+                        typedVariable,
+                        derivedTypePairs[0].DerivedTargetType);
+
+                    derivedTypeMappings.Add(ifSourceVariableIsDerivedTypeThenMap);
+                    continue;
+                }
+
+                var typePairsCondition = GetTypePairsCondition(derivedTypePairs, declaredTypeMapperData);
+
+                ifTypePairsConditionThenMap = GetIfConditionThenMapExpression(
+                    declaredTypeMappingData,
+                    typePairsCondition,
+                    typedVariable,
+                    derivedTypePairs[0].DerivedTargetType);
+
+                var mapToDerivedType = GetReturnMappingResultExpression(
+                    declaredTypeMappingData,
+                    typedVariable,
+                    targetType);
+
+                ifSourceVariableIsDerivedTypeThenMap = Expression.IfThen(
+                    condition,
+                    Expression.Block(ifTypePairsConditionThenMap, mapToDerivedType));
+
+                derivedTypeMappings.Add(ifSourceVariableIsDerivedTypeThenMap);
             }
         }
 
-        private static Expression GetTypePairCondition(
+        private static Expression GetIfConditionThenMapExpression(
+            IObjectMappingData mappingData,
+            Expression condition,
             Expression typedVariable,
-            Type derivedSourceType,
-            ref Type targetType,
-            IMemberMapperData mapperData)
+            Type targetType)
         {
-            Expression condition = typedVariable.GetIsNotDefaultComparison();
-
-            var derivedTypePairs = GetTypePairsFor(derivedSourceType, targetType, mapperData);
+            var returnMappingResult = GetReturnMappingResultExpression(mappingData, typedVariable, targetType);
+            var ifConditionThenMap = Expression.IfThen(condition, returnMappingResult);
 
-            if (derivedTypePairs.Any())
-            {
-                targetType = derivedTypePairs[0].DerivedTargetType;
-                condition = AppendTypePairConditionIfRequired(condition, derivedTypePairs, mapperData);
-            }
+            return ifConditionThenMap;
+        }
 
-            condition = AppendTargetValidCheckIfAppropriate(condition, targetType, mapperData);
+        private static Expression GetReturnMappingResultExpression(
+            IObjectMappingData mappingData,
+            Expression typedVariable,
+            Type targetType)
+        {
+            var mapping = MappingFactory.GetDerivedTypeMapping(mappingData, typedVariable, targetType);
+            var returnMappingResult = Expression.Return(mappingData.MapperData.ReturnLabelTarget, mapping);
 
-            return condition;
+            return returnMappingResult;
         }
 
         private static IList<DerivedTypePair> GetTypePairsFor(
@@ -181,27 +223,21 @@ private static IList<DerivedTypePair> GetTypePairsFor(
             return derivedTypePairs;
         }
 
-        private static Expression AppendTypePairConditionIfRequired(
-            Expression condition,
+        private static Expression GetTypePairsCondition(
             IEnumerable<DerivedTypePair> derivedTypePairs,
             IMemberMapperData mapperData)
         {
             var conditionalPairs = derivedTypePairs
                 .Where(pair => pair.HasConfiguredCondition)
                 .ToArray();
 
-            if (conditionalPairs.None())
-            {
-                return condition;
-            }
-
             var pairConditions = conditionalPairs.Skip(1).Aggregate(
                 conditionalPairs[0].GetConditionOrNull(mapperData),
                 (conditionSoFar, pair) => Expression.OrElse(
                     conditionSoFar,
                     pair.GetConditionOrNull(mapperData)));
 
-            return Expression.AndAlso(condition, pairConditions);
+            return pairConditions;
         }
 
         private static Expression AppendTargetValidCheckIfAppropriate(