Reusing MappingTypes instances when runtime types aren't needed

Author: SteveWilkes

AgileMapper/Members/MappingTypes.cs

@@ -63,12 +63,19 @@ public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
                 targetType = typeof(TTarget);
             }
 
+            var runtimeTypesNeeded = runtimeSourceTypeNeeded || runtimeTargetTypeNeeded;
+
+            if (!runtimeTypesNeeded)
+            {
+                return Fixed<TSource, TTarget>();
+            }
+
             var isEnumerable = TypeInfo<TTarget>.IsEnumerable || (!runtimeTypesAreTheSame && targetType.IsEnumerable());
 
             return new MappingTypes(
                 sourceType,
                 targetType,
-                runtimeSourceTypeNeeded || runtimeTargetTypeNeeded,
+                true, // <- runtimeTypesNeeded
                 runtimeTypesAreTheSame,
                 isEnumerable);
         }
@@ -86,7 +93,14 @@ public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
         public bool IsEnumerable { get; }
 
         public bool Equals(MappingTypes otherTypes)
-            => (otherTypes.SourceType == SourceType) && (otherTypes.TargetType == TargetType);
+        {
+            if (otherTypes == this)
+            {
+                return true;
+            }
+
+            return (otherTypes.SourceType == SourceType) && (otherTypes.TargetType == TargetType);
+        }
 
         public MappingTypes WithTypes<TNewSource, TNewTarget>()
         {

AgileMapper/ObjectPopulation/ObjectMapperCacheExtensions.cs

@@ -15,9 +15,14 @@ public static IObjectMapper GetOrAddMapper(
 
             var mapper = objectMapperCache.GetOrAdd(
                 mappingData.MapperKey,
-                key => key.MappingData.Mapper);
+                key =>
+                {
+                    var mapperToCache = key.MappingData.Mapper;
 
-            mappingData.MapperKey.MappingData = null;
+                    key.MappingData = null;
+
+                    return mapperToCache;
+                });
 
             return mapper;
         }

AgileMapper/ObjectPopulation/ObjectMapperFactory.cs

@@ -2,8 +2,6 @@ namespace AgileObjects.AgileMapper.ObjectPopulation
 {
     using System.Linq.Expressions;
     using Caching;
-    using Extensions;
-    using Members;
 
     internal class ObjectMapperFactory
     {

AgileMapper/ObjectPopulation/ObjectMapperKeyBase.cs

@@ -28,8 +28,16 @@ protected bool SourceHasRequiredTypes(ObjectMapperKeyBase otherKey)
         public abstract IMembersSource GetMembersSource(IObjectMappingData parentMappingData);
 
         public ObjectMapperKeyBase WithTypes<TNewSource, TNewTarget>()
-            => CreateInstance(MappingTypes.WithTypes<TNewSource, TNewTarget>());
+        {
+            var mappingTypes = MappingTypes.RuntimeTypesNeeded
+                ? MappingTypes.WithTypes<TNewSource, TNewTarget>()
+                : MappingTypes.Fixed<TNewSource, TNewTarget>();
+
+            return CreateInstance(mappingTypes);
+        }
 
         protected abstract ObjectMapperKeyBase CreateInstance(MappingTypes newMappingTypes);
+
+
     }
 }