Support for data source specification with .Map(s => s.Value, t => t.Member)

Author: SteveWilkes

AgileMapper.UnitTests/Configuration/Inline/WhenConfiguringDataSourcesInline.cs

@@ -131,15 +131,13 @@ public void ShouldApplyInlineConstantDataSourceExpressionsConditionally()
                     .Map(source1)
                     .ToANew<PublicField<string>>(c => c
                         .If((pp, pf) => pp.Value != "No")
-                        .Map("Maybe?")
-                        .To(pf => pf.Value));
+                        .Map("Maybe?", pf => pf.Value));
 
                 var result2 = mapper
                     .Map(source2)
                     .ToANew<PublicField<string>>(c => c
                         .If((pp, pf) => pp.Value != "No")
-                        .Map("Maybe?")
-                        .To(pf => pf.Value));
+                        .Map("Maybe?", pf => pf.Value));
 
                 result1.Value.ShouldBe("Maybe?");
                 result2.Value.ShouldBe("No");

AgileMapper.UnitTests/Configuration/WhenConfiguringDataSources.cs

@@ -134,8 +134,7 @@ public void ShouldApplyMultipleConfiguredMembersBySourceType()
                 mapper.WhenMapping
                     .From<Customer>()
                     .To<PublicProperty<string>>()
-                    .Map((p, t) => p.Discount)
-                    .To(x => x.Value);
+                    .Map(c => c.Discount, pp => pp.Value);
 
                 var personSource = new Person { Name = "Wilma" };
                 var personResult = mapper.Map(personSource).ToANew<PublicProperty<string>>();
@@ -330,8 +329,7 @@ public void ShouldApplyAConfiguredMemberInARootEnumerable()
                 mapper.WhenMapping
                     .From<Person>()
                     .To<PublicField<string>>()
-                    .Map(ctx => ctx.Source.Name)
-                    .To(x => x.Value);
+                    .Map(p => p.Name, pf => pf.Value);
 
                 var source = new[] { new Person { Name = "Mr Thomas" } };
                 var result = mapper.Map(source).ToANew<List<PublicField<string>>>();
@@ -691,8 +689,7 @@ public void ShouldApplyAConfiguredComplexTypeEnumerable()
                 mapper.WhenMapping
                     .From(source)
                     .To<PublicProperty<IEnumerable<Person>>>()
-                    .Map((s, pp) => s.People)
-                    .To(pp => pp.Value);
+                    .Map(s => s.People, pp => pp.Value);
 
                 var result = mapper.Map(source).ToANew<PublicProperty<IEnumerable<Person>>>();
 

AgileMapper/Api/Configuration/CustomDataSourceTargetMemberSpecifier.cs

@@ -164,7 +164,7 @@ private ConfiguredLambdaInfo GetValueLambdaInfo<TTargetValue>()
 #endif
             if ((customValueLambda.Body.NodeType != CONSTANT) ||
                 (typeof(TTargetValue) == typeof(object)) ||
-                customValueLambda.ReturnType.IsAssignableTo(typeof(TTargetValue)))
+                 customValueLambda.ReturnType.IsAssignableTo(typeof(TTargetValue)))
             {
                 return ConfiguredLambdaInfo.For(customValueLambda);
             }

AgileMapper/Api/Configuration/IRootMappingConfigurator.cs

@@ -99,6 +99,23 @@ IMappingConfigContinuation<TSource, TTarget> CreateInstancesUsing<TFactory>(TFac
         IMappingConfigContinuation<TSource, TTarget> IgnoreTargetMembersWhere(
             Expression<Func<TargetMemberSelector, bool>> memberFilter);
 
+        /// <summary>
+        /// Configure a custom data source for the given <paramref name="targetMember"/> when mapping from and to the
+        /// source and target types being configured. The factory expression is passed a context object containing the
+        /// current mapping's source and target objects.
+        /// </summary>
+        /// <typeparam name="TSourceValue">The type of the custom value being configured.</typeparam>
+        /// <typeparam name="TTargetValue">The target member's type.</typeparam>
+        /// <param name="valueFactoryExpression">The expression to map to the configured target member.</param>
+        /// <param name="targetMember">The target member to which to apply the configuration.</param>
+        /// <returns>
+        /// An IMappingConfigContinuation to enable further configuration of mappings from and to the source 
+        /// and target type being configured.
+        /// </returns>
+        IMappingConfigContinuation<TSource, TTarget> Map<TSourceValue, TTargetValue>(
+            Expression<Func<TSource, TSourceValue>> valueFactoryExpression,
+            Expression<Func<TTarget, TTargetValue>> targetMember);
+
         /// <summary>
         /// Configure a custom data source for a particular target member when mapping from and to the source and 
         /// target types being configured. The factory expression is passed a context object containing the current 
@@ -164,5 +181,21 @@ ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> MapFunc<TSourceV
         /// custom constant value should be applied.
         /// </returns>
         ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(TSourceValue value);
+
+        /// <summary>
+        /// Configure a constant value for the given <paramref name="targetMember"/> when mapping from and to the
+        /// source and target types being configured.
+        /// </summary>
+        /// <typeparam name="TSourceValue">The type of the custom constant value being configured.</typeparam>
+        /// <typeparam name="TTargetValue">The target member's type.</typeparam>
+        /// <param name="value">The constant value to map to the configured target member.</param>
+        /// <param name="targetMember">The target member to which to apply the configuration.</param>
+        /// <returns>
+        /// An IMappingConfigContinuation to enable further configuration of mappings from and to the source 
+        /// and target type being configured.
+        /// </returns>
+        IMappingConfigContinuation<TSource, TTarget> Map<TSourceValue, TTargetValue>(
+            TSourceValue value,
+            Expression<Func<TTarget, TTargetValue>> targetMember);
     }
 }

AgileMapper/Api/Configuration/MappingConfigurator.cs

@@ -318,6 +318,13 @@ public PostEventMappingConfigStartingPoint<TSource, TTarget> After
 
         #region Map Overloads
 
+        public IMappingConfigContinuation<TSource, TTarget> Map<TSourceValue, TTargetValue>(
+            Expression<Func<TSource, TSourceValue>> valueFactoryExpression,
+            Expression<Func<TTarget, TTargetValue>> targetMember)
+        {
+            return GetValueFactoryTargetMemberSpecifier<TSourceValue>(valueFactoryExpression).To(targetMember);
+        }
+
         public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(
             Expression<Func<IMappingData<TSource, TTarget>, TSourceValue>> valueFactoryExpression)
         {
@@ -349,6 +356,13 @@ public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> MapFunc<T
         public ICustomMappingDataSourceTargetMemberSpecifier<TSource, TTarget> Map<TSourceValue>(TSourceValue value)
             => GetConstantValueTargetMemberSpecifier(value);
 
+        public IMappingConfigContinuation<TSource, TTarget> Map<TSourceValue, TTargetValue>(
+            TSourceValue value,
+            Expression<Func<TTarget, TTargetValue>> targetMember)
+        {
+            return GetConstantValueTargetMemberSpecifier(value).To(targetMember);
+        }
+
         ICustomProjectionDataSourceTargetMemberSpecifier<TSource, TTarget> IRootProjectionConfigurator<TSource, TTarget>.Map<TSourceValue>(
             TSourceValue value)
         {

AgileMapper/Configuration/ConfiguredLambdaInfo.cs

@@ -54,12 +54,14 @@ private static Type[] GetContextTypes(Type[] funcArguments)
                 return funcArguments;
             }
 
-            if (funcArguments[0].IsGenericType())
+            var firstArgument = funcArguments[0];
+
+            if (firstArgument.IsGenericType() && !firstArgument.IsAnonymous())
             {
-                return funcArguments[0].GetGenericTypeArguments();
+                return firstArgument.GetGenericTypeArguments();
             }
 
-            return new[] { funcArguments[0] };
+            return new[] { firstArgument };
         }
 
         public static ConfiguredLambdaInfo ForFunc<TFunc>(TFunc func, params Type[] argumentTypes)