Simplifying exception information creation

Author: SteveWilkes

AgileMapper.UnitTests/Configuration/WhenConfiguringObjectCreation.cs

@@ -308,18 +308,23 @@ public void ShouldUseConfiguredFactoriesForBaseAndDerivedTypes()
         [Fact]
         public void ShouldHandleAnObjectMappingDataCreationException()
         {
-            using (var mapper = Mapper.CreateNew())
+            var thrownException = Should.Throw<MappingException>(() =>
             {
-                mapper.After.MappingEnds.Call(Console.WriteLine);
+                using (var mapper = Mapper.CreateNew())
+                {
+                    mapper.After.MappingEnds.Call(Console.WriteLine);
 
-                var source = new PublicField<Product> { Value = new Product() };
+                    var source = new PublicField<Product> { Value = new Product() };
 
-                var thrownException = Should.Throw<MappingException>(() => mapper.Map(source).ToANew<ExceptionThrower<Product>>());
+                    mapper.Map(source).ToANew<ExceptionThrower<Product>>();
 
-                thrownException.InnerException.ShouldNotBeNull();
-                // ReSharper disable once PossibleNullReferenceException
-                thrownException.InnerException.Message.ShouldBe(MappingException.NoMappingData);
-            }
+                }
+            });
+
+            thrownException.InnerException.ShouldNotBeNull();
+
+            // ReSharper disable once PossibleNullReferenceException
+            thrownException.InnerException.Message.ShouldContain("An exception occurred mapping");
         }
 
         [Fact]

AgileMapper.UnitTests/WhenViewingMappingPlans.cs

@@ -55,10 +55,8 @@ public void ShouldSupportAnonymousSourceTypesFromTheInstanceApi()
                     .OnTo<Customer>();
 
                 plan.ShouldContain("Map AnonymousType<string, string> -> Customer");
-                plan.ShouldContain(".Target.Name = sourceF__AnonymousType");
-                plan.ShouldContain("_String_String.Name;");
-                plan.ShouldContain("address.Line1 = sourceF__AnonymousType");
-                plan.ShouldContain("_String_String.AddressLine1;");
+                plan.ShouldContain(".Target.Name = fatssToCData.Source.Name");
+                plan.ShouldContain("address.Line1 = fatssToCData.Source.AddressLine1");
             }
         }
 

AgileMapper/MappingException.cs

@@ -1,13 +1,14 @@
 namespace AgileObjects.AgileMapper
 {
     using System;
+    using System.Linq.Expressions;
     using System.Reflection;
 #if SERIALIZATION_SUPPORTED
     using System.Runtime.Serialization;
 #endif
+    using Extensions.Internal;
     using Members;
     using NetStandardPolyfills;
-    using ObjectPopulation;
 
     /// <summary>
     /// Represents an error that occurred during a mapping.
@@ -19,11 +20,9 @@
     #endregion
     public class MappingException : Exception
     {
-        internal static readonly MethodInfo FactoryMethod =
+        private static readonly MethodInfo _factoryMethod =
             typeof(MappingException).GetPublicStaticMethod("For");
 
-        internal const string NoMappingData = "An exception occurred creating a mapping data instance";
-
         #region Serialization Support
 #if SERIALIZATION_SUPPORTED
         /// <summary>
@@ -40,41 +39,44 @@ protected MappingException(SerializationInfo info, StreamingContext context)
 #endif
         #endregion
 
-        private MappingException(IMemberMapperData mapperData, Exception innerException)
-            : base(GetMessage(mapperData), innerException)
+        private MappingException(string message, Exception innerException)
+            : base(message, innerException)
         {
         }
 
         /// <summary>
         /// Creates a new instance of the MappingException class.
         /// </summary>
-        /// <typeparam name="TSource">The source type being mapped when the exception occurred.</typeparam>
-        /// <typeparam name="TTarget">The target type being mapped when the exception occurred.</typeparam>
-        /// <param name="mappingData">
-        /// The <see cref="IObjectMappingData{TSource, TTarget}"/> containing the mapping data of the 
-        /// current mapping context.
-        /// </param>
+        /// <param name="ruleSetName">The name of the mapping rule set being executed when the exception occurred.</param>
+        /// <param name="sourcePath">The path of the source object being mapped when the exception occurred.</param>
+        /// <param name="targetPath">The path of the target object being mapped when the exception occurred.</param>
         /// <param name="innerException">The exception which caused the creation of the MappingException.</param>
         /// <returns>A new MappingException instance.</returns>
-        public static MappingException For<TSource, TTarget>(
-            IObjectMappingData<TSource, TTarget> mappingData,
+        public static MappingException For(
+            string ruleSetName,
+            string sourcePath,
+            string targetPath,
             Exception innerException)
         {
-            return new MappingException(((IObjectMappingData)mappingData)?.MapperData, innerException);
+            return new MappingException(
+                $"An exception occurred mapping {sourcePath} -> {targetPath} with rule set {ruleSetName}.",
+                innerException);
         }
 
-        private static string GetMessage(IMemberMapperData mapperData)
+        internal static Expression GetFactoryMethodCall(IMemberMapperData mapperData, Expression exceptionVariable)
         {
-            if (mapperData == null)
-            {
-                return NoMappingData;
-            }
-
             var rootData = mapperData.GetRootMapperData();
             var sourcePath = mapperData.SourceMember.GetFriendlySourcePath(rootData);
             var targetPath = mapperData.TargetMember.GetFriendlyTargetPath(rootData);
 
-            return $"An exception occurred mapping {sourcePath} -> {targetPath} with rule set {mapperData.RuleSet.Name}.";
+            var mappingExceptionCreation = Expression.Call(
+                _factoryMethod,
+                mapperData.RuleSet.NameConstant,
+                sourcePath.ToConstantExpression(),
+                targetPath.ToConstantExpression(),
+                exceptionVariable);
+
+            return mappingExceptionCreation;
         }
     }
 }

AgileMapper/MappingRuleSet.cs

@@ -1,6 +1,8 @@
 namespace AgileObjects.AgileMapper
 {
+    using System.Linq.Expressions;
     using DataSources;
+    using Extensions.Internal;
     using Members.Population;
     using ObjectPopulation.Enumerables;
     using ObjectPopulation.Recursion;
@@ -16,6 +18,7 @@ public MappingRuleSet(
             IDataSourceFactory fallbackDataSourceFactory)
         {
             Name = name;
+            NameConstant = name.ToConstantExpression();
             Settings = settings;
             EnumerablePopulationStrategy = enumerablePopulationStrategy;
             RecursiveMemberMappingStrategy = recursiveMemberMappingStrategy;
@@ -25,6 +28,8 @@ public MappingRuleSet(
 
         public string Name { get; }
 
+        public Expression NameConstant { get; }
+
         public MappingRuleSetSettings Settings { get; }
 
         public IEnumerablePopulationStrategy EnumerablePopulationStrategy { get; }

AgileMapper/ObjectPopulation/MappingExpressionFactoryBase.cs

@@ -370,15 +370,9 @@ private static Expression WrapInTryCatch(Expression mappingBlock, IMemberMapperD
             }
             else
             {
-                var exceptionFactoryMethod = MappingException.FactoryMethod
-                    .MakeGenericMethod(mapperData.SourceType, mapperData.TargetType);
-
-                var mappingExceptionCreation = Expression.Call(
-                    exceptionFactoryMethod,
-                    mapperData.MappingDataObject,
-                    exceptionVariable);
-
-                catchBody = Expression.Throw(mappingExceptionCreation, mappingBlock.Type);
+                catchBody = Expression.Throw(
+                    MappingException.GetFactoryMethodCall(mapperData, exceptionVariable),
+                    mappingBlock.Type);
             }
 
             var catchBlock = Expression.Catch(exceptionVariable, catchBody);