Using statically-cached root mapper keys where possible / Lazy-loading MappingRuleSet name constant Expression

Author: SteveWilkes

AgileMapper/MappingExecutor.cs

@@ -8,6 +8,7 @@
     using Api;
     using Api.Configuration;
     using Extensions.Internal;
+    using Members;
     using ObjectPopulation;
 
     internal class MappingExecutor<TSource> :
@@ -126,19 +127,19 @@ private TTarget PerformMapping<TTarget>(
 
         private TTarget PerformMapping<TTarget>(TTarget target)
         {
-            if (TypeInfo<TSource>.RuntimeTypeNeeded || TypeInfo<TTarget>.RuntimeTypeNeeded)
+            if (MappingTypes<TSource, TTarget>.SkipTypesCheck)
             {
-                var rootMappingData = ObjectMappingDataFactory.ForRoot(_source, target, this);
-                var result = rootMappingData.MapStart();
+                // Optimise for the most common scenario:
+                var typedRootMappingData = ObjectMappingDataFactory
+                    .ForRootFixedTypes(_source, target, this);
 
-                return (TTarget)result;
+                return typedRootMappingData.MapStart();
             }
 
-            // Optimise for the most common scenario:
-            var typedRootMappingData = ObjectMappingDataFactory
-                .ForRootFixedTypes(_source, target, this);
+            var rootMappingData = ObjectMappingDataFactory.ForRoot(_source, target, this);
+            var result = rootMappingData.MapStart();
 
-            return typedRootMappingData.MapStart();
+            return (TTarget)result;
         }
 
         #region IFlatteningSelector Members

AgileMapper/MappingRuleSet.cs

@@ -9,6 +9,8 @@ namespace AgileObjects.AgileMapper
 
     internal class MappingRuleSet
     {
+        private Expression _nameConstant;
+
         public MappingRuleSet(
             string name,
             MappingRuleSetSettings settings,
@@ -18,7 +20,6 @@ public MappingRuleSet(
             IDataSourceFactory fallbackDataSourceFactory)
         {
             Name = name;
-            NameConstant = name.ToConstantExpression();
             Settings = settings;
             EnumerablePopulationStrategy = enumerablePopulationStrategy;
             RecursiveMemberMappingStrategy = recursiveMemberMappingStrategy;
@@ -28,7 +29,7 @@ public MappingRuleSet(
 
         public string Name { get; }
 
-        public Expression NameConstant { get; }
+        public Expression NameConstant => _nameConstant ?? (_nameConstant = Name.ToConstantExpression());
 
         public MappingRuleSetSettings Settings { get; }
 

AgileMapper/ObjectPopulation/ObjectMapperFactory.cs

@@ -49,7 +49,7 @@ public ObjectMapper<TSource, TTarget> GetOrCreateRoot<TSource, TTarget>(ObjectMa
                 return mapper;
             }
 
-            mappingData.MapperKey.MappingData = mappingData;
+            mappingData.GenerateUniqueRootKey();
 
             mapper = (ObjectMapper<TSource, TTarget>)_rootMappersCache.GetOrAdd(
                 mappingData.MapperKey,

AgileMapper/ObjectPopulation/ObjectMappingData.cs

@@ -67,7 +67,15 @@ private ObjectMappingData(
 
         public MapperContext MapperContext => MappingContext.MapperContext;
 
-        public ObjectMapperKeyBase MapperKey { get; }
+        public ObjectMapperKeyBase MapperKey { get; private set; }
+
+        public void GenerateUniqueRootKey()
+        {
+            MapperKey = new RootObjectMapperKey(MapperKey.MappingTypes, MappingContext)
+            {
+                MappingData = this
+            };
+        }
 
         public IObjectMapper GetOrCreateMapper()
         {

AgileMapper/ObjectPopulation/ObjectMappingDataFactory.cs

@@ -45,7 +45,7 @@ public static ObjectMappingData<TSource, TTarget> ForRootFixedTypes<TSource, TTa
             return ForRootFixedTypes(
                 source,
                 target,
-                new RootObjectMapperKey(MappingTypes<TSource, TTarget>.Fixed, mappingContext),
+                RootObjectMapperKey.Cache<TSource, TTarget>.GetKeyFor(mappingContext),
                 mappingContext);
         }
 

AgileMapper/ObjectPopulation/RootObjectMapperKey.cs

@@ -15,7 +15,7 @@ public RootObjectMapperKey(MappingTypes mappingTypes, IMappingContext mappingCon
         {
         }
 
-        private RootObjectMapperKey(MappingRuleSet ruleSet, MappingTypes mappingTypes, MapperContext mapperContext)
+        public RootObjectMapperKey(MappingRuleSet ruleSet, MappingTypes mappingTypes, MapperContext mapperContext)
             : base(mappingTypes)
         {
             _mapperContext = mapperContext;
@@ -57,5 +57,57 @@ public override string ToString()
         }
 #endif
         #endregion
+
+        public static class Cache<TSource, TTarget>
+        {
+            // ReSharper disable StaticMemberInGenericType
+            private static ObjectMapperKeyBase _createNew;
+            private static ObjectMapperKeyBase _overwrite;
+            private static ObjectMapperKeyBase _project;
+            private static ObjectMapperKeyBase _merge;
+            // ReSharper restore StaticMemberInGenericType
+
+            private static ObjectMapperKeyBase CreateNew
+                => _createNew ?? (_createNew = CreateKey(MappingRuleSetCollection.Default.CreateNew));
+
+            private static ObjectMapperKeyBase Overwrite
+                => _overwrite ?? (_overwrite = CreateKey(MappingRuleSetCollection.Default.Overwrite));
+
+            private static ObjectMapperKeyBase Project
+                => _project ?? (_project = CreateKey(MappingRuleSetCollection.Default.Project));
+
+            private static ObjectMapperKeyBase Merge
+                => _merge ?? (_merge = CreateKey(MappingRuleSetCollection.Default.Merge));
+
+            private static ObjectMapperKeyBase CreateKey(MappingRuleSet ruleSet)
+            {
+                return new RootObjectMapperKey(
+                    ruleSet,
+                    MappingTypes<TSource, TTarget>.Fixed,
+                    mapperContext: null);
+            }
+
+            public static ObjectMapperKeyBase GetKeyFor(IMappingContext mappingContext)
+            {
+                var ruleSets = mappingContext.MapperContext.RuleSets;
+
+                if (mappingContext.RuleSet == ruleSets.CreateNew)
+                {
+                    return CreateNew;
+                }
+
+                if (mappingContext.RuleSet == ruleSets.Overwrite)
+                {
+                    return Overwrite;
+                }
+
+                if (mappingContext.RuleSet == ruleSets.Project)
+                {
+                    return Project;
+                }
+
+                return Merge;
+            }
+        }
     }
 }