Optimising root mapping plan mapping data creation

Author: SteveWilkes

AgileMapper.UnitTests/Members/WhenFindingDataSources.cs

@@ -1,6 +1,7 @@
 namespace AgileObjects.AgileMapper.UnitTests.Members
 {
     using AgileMapper.Members;
+    using ObjectPopulation;
     using Shouldly;
     using TestClasses;
     using Xunit;
@@ -15,7 +16,7 @@ public void ShouldNotMatchSameNameIncompatibleTypeProperties()
             var targetMember = TargetMemberFor<PublicProperty<byte>>(x => x.Value);
 
             var mappingContext = new MappingExecutor<TwoValues>(DefaultMapperContext.RuleSets.CreateNew, DefaultMapperContext);
-            var rootMappingData = mappingContext.CreateRootMappingData(source, target);
+            var rootMappingData = ObjectMappingDataFactory.ForRoot(source, target, mappingContext);
             var rootMapperData = rootMappingData.MapperData;
 
             var childMapperData = new ChildMemberMapperData(targetMember, rootMapperData);

AgileMapper/IMappingContext.cs

@@ -1,13 +1,9 @@
 namespace AgileObjects.AgileMapper
 {
-    using ObjectPopulation;
-
     internal interface IMappingContext
     {
         MapperContext MapperContext { get; }
 
         MappingRuleSet RuleSet { get; }
-
-        IObjectMappingData CreateRootMappingData<TSource, TTarget>(TSource source, TTarget target);
     }
 }

AgileMapper/MappingExecutor.cs

@@ -5,7 +5,6 @@
     using Api;
     using Api.Configuration;
     using Extensions;
-    using Members;
     using ObjectPopulation;
 
     internal class MappingExecutor<TSource> : ITargetTypeSelector<TSource>, IMappingContext
@@ -97,38 +96,19 @@ private TTarget PerformMapping<TTarget>(MappingRuleSet ruleSet, TTarget target)
 
         private TTarget PerformMapping<TTarget>(TTarget target)
         {
-            if (SkipTypeChecks<TTarget>())
+            if (TypeInfo<TSource>.RuntimeTypeNeeded || TypeInfo<TTarget>.RuntimeTypeNeeded)
             {
-                // Optimise for the most common scenario:
-                var typedRootMappingData = CreateTypedRootMappingData(target);
+                var rootMappingData = ObjectMappingDataFactory.ForRoot(_source, target, this);
+                var result = rootMappingData.MapStart();
 
-                return typedRootMappingData.MapStart();
+                return (TTarget)result;
             }
 
-            var rootMappingData = CreateRootMappingData(target);
-            var result = rootMappingData.MapStart();
+            // Optimise for the most common scenario:
+            var typedRootMappingData = ObjectMappingDataFactory
+                .ForRootFixedTypes(_source, target, this);
 
-            return (TTarget)result;
+            return typedRootMappingData.MapStart();
         }
-
-        private static bool SkipTypeChecks<TTarget>()
-            => !(TypeInfo<TSource>.RuntimeTypeNeeded || TypeInfo<TTarget>.RuntimeTypeNeeded);
-
-        private ObjectMappingData<TSource, TTarget> CreateTypedRootMappingData<TTarget>(TTarget target)
-        {
-            return new ObjectMappingData<TSource, TTarget>(
-                _source,
-                target,
-                null, // <- No enumerable index because we're at the root
-                new RootObjectMapperKey(MappingTypes<TSource, TTarget>.Fixed, this),
-                this,
-                parent: null);
-        }
-
-        private IObjectMappingData CreateRootMappingData<TTarget>(TTarget target)
-            => CreateRootMappingData(_source, target);
-
-        public IObjectMappingData CreateRootMappingData<TDataSource, TDataTarget>(TDataSource source, TDataTarget target)
-            => ObjectMappingDataFactory.ForRoot(source, target, this);
     }
 }

AgileMapper/ObjectPopulation/ObjectMappingDataFactory.cs

@@ -16,6 +16,20 @@ internal class ObjectMappingDataFactory : IObjectMappingDataFactoryBridge
     {
         private static readonly IObjectMappingDataFactoryBridge _bridge = new ObjectMappingDataFactory();
 
+        public static ObjectMappingData<TSource, TTarget> ForRootFixedTypes<TSource, TTarget>(
+            TSource source,
+            TTarget target,
+            IMappingContext mappingContext)
+        {
+            return new ObjectMappingData<TSource, TTarget>(
+                source,
+                target,
+                null, // <- No enumerable index because we're at the root
+                new RootObjectMapperKey(MappingTypes<TSource, TTarget>.Fixed, mappingContext),
+                mappingContext,
+                parent: null);
+        }
+
         public static IObjectMappingData ForRoot<TSource, TTarget>(
             TSource source,
             TTarget target,

AgileMapper/ObjectPopulation/RootObjectMapperKey.cs

@@ -2,7 +2,9 @@ namespace AgileObjects.AgileMapper.ObjectPopulation
 {
     using Members;
     using Members.Sources;
+#if DEBUG
     using ReadableExpressions.Extensions;
+#endif
 
     internal class RootObjectMapperKey : ObjectMapperKeyBase
     {
@@ -37,14 +39,14 @@ public override bool Equals(object obj)
                    SourceHasRequiredTypes(otherKey);
         }
 
-        #region ExcludeFromCodeCoverage
+#region ExcludeFromCodeCoverage
 #if DEBUG
         [ExcludeFromCodeCoverage]
 #endif
-        #endregion
+#endregion
         public override int GetHashCode() => 0;
 
-        #region ToString
+#region ToString
 #if DEBUG
         [ExcludeFromCodeCoverage]
         public override string ToString()
@@ -55,6 +57,6 @@ public override string ToString()
             return $"{_ruleSet.Name}: {sourceTypeName} -> {targetTypeName}";
         }
 #endif
-        #endregion
+#endregion
     }
 }

AgileMapper/Plans/MappingPlan.cs

@@ -27,8 +27,8 @@ internal MappingPlan(IMappingContext mappingContext)
         {
             _generatedPlanData = new List<MappingPlanData>();
 
-            var rootMappingData = mappingContext
-                .CreateRootMappingData(default(TSource), default(TTarget));
+            var rootMappingData = ObjectMappingDataFactory
+                .ForRootFixedTypes(default(TSource), default(TTarget), mappingContext);
 
             var rootPlanData = new MappingPlanData(rootMappingData);