Removing unnecessary casting / Storing root mappers in a typed cache

Author: SteveWilkes

AgileMapper/ObjectPopulation/ObjectMapper.cs

@@ -86,12 +86,9 @@ private ICache<ObjectMapperKeyBase, IObjectMapperFunc> CreateRecursionMapperFunc
 
         public ObjectMapperData MapperData { get; }
 
-        public object Map(IObjectMappingData mappingData)
-        {
-            var typedData = (ObjectMappingData<TSource, TTarget>)mappingData;
+        public object Map(IObjectMappingData mappingData) => Map((ObjectMappingData<TSource, TTarget>)mappingData);
 
-            return _mapperFunc.Invoke(typedData);
-        }
+        public TTarget Map(ObjectMappingData<TSource, TTarget> mappingData) => _mapperFunc.Invoke(mappingData);
 
         public object MapChild<TDeclaredSource, TDeclaredTarget>(
             TDeclaredSource source,

AgileMapper/ObjectPopulation/ObjectMapperFactory.cs

@@ -1,24 +1,42 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation
 {
+    using System.Collections.Generic;
     using System.Linq.Expressions;
     using Caching;
 
     internal class ObjectMapperFactory
     {
         private readonly EnumerableMappingExpressionFactory _enumerableMappingExpressionFactory;
         private readonly ComplexTypeMappingExpressionFactory _complexTypeMappingExpressionFactory;
-        private readonly ICache<ObjectMapperKeyBase, IObjectMapper> _rootMappers;
+        private readonly List<ICacheEmptier> _rootCacheEmptiers;
 
         public ObjectMapperFactory(MapperContext mapperContext)
         {
             _enumerableMappingExpressionFactory = new EnumerableMappingExpressionFactory();
             _complexTypeMappingExpressionFactory = new ComplexTypeMappingExpressionFactory(mapperContext);
-            _rootMappers = mapperContext.Cache.CreateScoped<ObjectMapperKeyBase, IObjectMapper>();
+            _rootCacheEmptiers = new List<ICacheEmptier>();
         }
 
-        public IObjectMapper GetOrCreateRoot(IObjectMappingData mappingData) => _rootMappers.GetOrAddMapper(mappingData);
+        public ObjectMapper<TSource, TTarget> GetOrCreateRoot<TSource, TTarget>(ObjectMappingData<TSource, TTarget> mappingData)
+        {
+            mappingData.MapperKey.MappingData = mappingData;
+
+            var mapper = RootMapperCache<TSource, TTarget>.Mappers.GetOrAdd(
+                mappingData.MapperKey,
+                key =>
+                {
+                    var mapperToCache = (ObjectMapper<TSource, TTarget>)key.MappingData.Mapper;
+
+                    key.MappingData = null;
+                    _rootCacheEmptiers.Add(CacheEmptier<TSource, TTarget>.Instance);
 
-        public IObjectMapper Create<TSource, TTarget>(IObjectMappingData mappingData)
+                    return mapperToCache;
+                });
+
+            return mapper;
+        }
+
+        public ObjectMapper<TSource, TTarget> Create<TSource, TTarget>(ObjectMappingData<TSource, TTarget> mappingData)
         {
             var mappingExpression = mappingData.MapperKey.MappingTypes.IsEnumerable
                 ? _enumerableMappingExpressionFactory.Create(mappingData)
@@ -38,8 +56,45 @@ public IObjectMapper Create<TSource, TTarget>(IObjectMappingData mappingData)
 
         public void Reset()
         {
-            _rootMappers.Empty();
             _complexTypeMappingExpressionFactory.Reset();
+
+            foreach (var rootCacheEmptier in _rootCacheEmptiers)
+            {
+                rootCacheEmptier.EmptyCache();
+            }
+
+            _rootCacheEmptiers.Clear();
+        }
+
+        #region Root Mapper Caching
+
+        private static class RootMapperCache<TSource, TTarget>
+        {
+            public static readonly ICache<ObjectMapperKeyBase, ObjectMapper<TSource, TTarget>> Mappers;
+
+            static RootMapperCache()
+            {
+                Mappers = GlobalContext.Instance
+                    .Cache
+                    .CreateScoped<ObjectMapperKeyBase, ObjectMapper<TSource, TTarget>>();
+            }
+        }
+
+        private interface ICacheEmptier
+        {
+            void EmptyCache();
         }
+
+        private class CacheEmptier<TSource, TTarget> : ICacheEmptier
+        {
+            public static readonly ICacheEmptier Instance = new CacheEmptier<TSource, TTarget>();
+
+            public void EmptyCache()
+            {
+                RootMapperCache<TSource, TTarget>.Mappers.Empty();
+            }
+        }
+
+        #endregion
     }
 }

AgileMapper/ObjectPopulation/ObjectMappingData.cs

@@ -14,7 +14,7 @@ internal class ObjectMappingData<TSource, TTarget> :
     {
         private readonly IObjectMappingData _parent;
         private readonly Dictionary<object, List<object>> _mappedObjectsBySource;
-        private IObjectMapper _mapper;
+        private ObjectMapper<TSource, TTarget> _mapper;
         private ObjectMapperData _mapperData;
 
         public ObjectMappingData(
@@ -62,7 +62,7 @@ private ObjectMappingData(
                 return;
             }
 
-            Mapper = MapperContext.ObjectMapperFactory.GetOrCreateRoot(this);
+            _mapper = MapperContext.ObjectMapperFactory.GetOrCreateRoot(this);
 
             if (MapperData.MappedObjectCachingNeeded)
             {
@@ -76,16 +76,15 @@ private ObjectMappingData(
 
         public ObjectMapperKeyBase MapperKey { get; }
 
-        public IObjectMapper Mapper
+        IObjectMapper IObjectMappingData.Mapper
         {
-            get { return _mapper ?? (Mapper = MapperContext.ObjectMapperFactory.Create<TSource, TTarget>(this)); }
-            set
-            {
-                _mapper = value;
-                _mapperData = _mapper.MapperData;
-            }
+            get { return Mapper; }
+            set { _mapper = (ObjectMapper<TSource, TTarget>)value; }
         }
 
+        private ObjectMapper<TSource, TTarget> Mapper
+            => _mapper ?? (_mapper = MapperContext.ObjectMapperFactory.Create(this));
+
         public TTarget CreatedObject { get; set; }
 
         #region IObjectMappingData Members
@@ -101,7 +100,7 @@ public IObjectMapper Mapper
         public IObjectMappingData DeclaredTypeMappingData { get; }
 
         public ObjectMapperData MapperData
-            => _mapperData ?? (_mapperData = ObjectMapperData.For<TSource, TTarget>(this));
+            => _mapperData ?? (_mapperData = _mapper?.MapperData ?? ObjectMapperData.For<TSource, TTarget>(this));
 
         private ChildMemberMappingData<TSource, TTarget> _childMappingData;
 
@@ -121,7 +120,7 @@ IMemberMappingData IObjectMappingData.GetChildMappingData(IMemberMapperData chil
 
         #region Map Methods
 
-        public object MapStart() => Mapper.Map(this);
+        public object MapStart() => _mapper.Map(this);
 
         public TDeclaredTarget Map<TDeclaredSource, TDeclaredTarget>(
             TDeclaredSource sourceValue,

AgileMapper/ObjectPopulation/ObjectMappingDataFactory.cs

@@ -171,7 +171,7 @@ object IObjectMappingDataFactoryBridge.ForElement<TSource, TTarget>(object membe
         public static IObjectMappingData ForElement<TSource, TTarget>(
             TSource source,
             TTarget target,
-            int? enumerableIndex,
+            int enumerableIndex,
             IObjectMappingData parent)
         {
             var membersSource = new ElementMembersSource(parent);
@@ -187,7 +187,7 @@ public static IObjectMappingData ForElement<TSource, TTarget>(
         private static IObjectMappingData ForElement<TSource, TTarget>(
             TSource source,
             TTarget target,
-            int? enumerableIndex,
+            int enumerableIndex,
             IMembersSource membersSource,
             IObjectMappingData parent)
         {

AgileMapper/ObjectPopulation/RootObjectMapperKey.cs

@@ -32,13 +32,11 @@ public override bool Equals(object obj)
         {
             var otherKey = (RootObjectMapperKey)obj;
 
-            // ReSharper disable once PossibleNullReferenceException
-            if ((otherKey._ruleSet == _ruleSet) && TypesMatch(otherKey))
-            {
-                return SourceHasRequiredTypes(otherKey);
-            }
+            // ObjectMapperFactory stores root mappers in a static, typed cache, 
+            // so MappingTypes checks are unnecessary
 
-            return false;
+            // ReSharper disable once PossibleNullReferenceException
+            return (otherKey._ruleSet == _ruleSet) && SourceHasRequiredTypes(otherKey);
         }
 
         public override int GetHashCode() => 0;