Lazy-loading recursion mapper funcs deemed necessary during execution of a recursion mapper func; fixes issue #62

Author: SteveWilkes

AgileMapper.UnitTests/WhenMappingCircularReferences.cs

@@ -391,6 +391,42 @@ public void ShouldMapNestedMultiplyRecursiveRelationships()
             resultTwo.ChildRecursor.ShouldBeSameAs(resultOne);
         }
 
+        // See https://github.com/agileobjects/AgileMapper/issues/62
+        [Fact]
+        public void ShouldMapChildOneToManyRecursiveRelationships()
+        {
+            var sourceLocation1 = new Location { Id = 1 };
+            var sourceLocation2 = new Location { Id = 2 };
+
+            sourceLocation1.LocationPlace = sourceLocation2.LocationPlace = new Place
+            {
+                Locations = new[] { sourceLocation1, sourceLocation2 }
+            };
+
+            var source = new[] { sourceLocation1, sourceLocation2 };
+
+            var result = Mapper
+                .Map<IEnumerable<Location>>(source)
+                .ToANew<IEnumerable<DtoLocation>>()
+                .ToArray();
+
+            result.Length.ShouldBe(2);
+
+            var dtoLocation1 = result.First();
+            dtoLocation1.Id.ShouldBe(1);
+            dtoLocation1.LocationPlace.ShouldNotBeNull();
+
+            var dtoLocation2 = result.Second();
+            dtoLocation2.Id.ShouldBe(2);
+            dtoLocation2.LocationPlace.ShouldNotBeNull();
+            dtoLocation2.LocationPlace.Locations.Count().ShouldBe(2);
+
+            dtoLocation2.LocationPlace.ShouldBeSameAs(dtoLocation1.LocationPlace);
+            dtoLocation2.LocationPlace.Locations.Count().ShouldBe(2);
+            dtoLocation2.LocationPlace.Locations.First().ShouldBe(dtoLocation1);
+            dtoLocation2.LocationPlace.Locations.Second().ShouldBe(dtoLocation2);
+        }
+
         [Fact]
         public void ShouldUseConfiguredRecursiveDataSources()
         {
@@ -547,6 +583,30 @@ internal class SubjectPresenter
             public Presenter Presenter { get; set; }
         }
 
+        public class Location
+        {
+            public int Id { get; set; }
+
+            public Place LocationPlace { get; set; }
+        }
+
+        public class Place
+        {
+            public IEnumerable<Location> Locations { get; set; }
+        }
+
+        public class DtoLocation
+        {
+            public int Id { get; set; }
+
+            public DtoPlace LocationPlace { get; set; }
+        }
+
+        public class DtoPlace
+        {
+            public IEnumerable<DtoLocation> Locations { get; set; }
+        }
+
         #endregion
     }
 }

AgileMapper/Caching/ReferenceEqualsComparer.cs

@@ -6,6 +6,6 @@ internal struct ReferenceEqualsComparer<T> : IEqualityComparer<T>
     {
         public bool Equals(T x, T y) => ReferenceEquals(x, y);
 
-        public int GetHashCode(T obj) => 0;
+        public int GetHashCode(T obj) => obj.GetHashCode();
     }
 }

AgileMapper/Extensions/Internal/ExpressionExtensions.Replace.cs

@@ -4,6 +4,7 @@
     using System.Collections.Generic;
     using System.Linq;
     using System.Linq.Expressions;
+    using Caching;
     using static System.Linq.Expressions.ExpressionType;
 
     internal static partial class ExpressionExtensions
@@ -55,7 +56,7 @@ public static TExpression Replace<TExpression>(
             return new ExpressionReplacer(
                     target,
                     replacement,
-                    comparer ?? ReferenceEqualsEqualityComparer.Instance)
+                    comparer ?? default(ReferenceEqualsComparer<Expression>))
                 .Replace<TExpression>(expression);
         }
 
@@ -348,15 +349,5 @@ private Expression ReplaceIn<TExpression>(TExpression expression, Func<TExpressi
                 return replacer.Invoke(expression);
             }
         }
-
-        private class ReferenceEqualsEqualityComparer : IEqualityComparer<Expression>
-        {
-            public static readonly IEqualityComparer<Expression> Instance =
-                new ReferenceEqualsEqualityComparer();
-
-            public bool Equals(Expression x, Expression y) => x == y;
-
-            public int GetHashCode(Expression obj) => obj.GetHashCode();
-        }
     }
 }

AgileMapper/Members/MemberMapperDataExtensions.cs

@@ -46,14 +46,14 @@ public static bool UseMemberInitialisations(this IMemberMapperData mapperData)
         public static bool MapToNullCollections(this IMemberMapperData mapperData)
             => mapperData.MapperContext.UserConfigurations.MapToNullCollections(mapperData);
 
-        public static IMemberMapperData GetRootMapperData(this IMemberMapperData mapperData)
+        public static ObjectMapperData GetRootMapperData(this IMemberMapperData mapperData)
         {
             while (!mapperData.IsRoot)
             {
                 mapperData = mapperData.Parent;
             }
 
-            return mapperData;
+            return (ObjectMapperData)mapperData;
         }
 
         public static IBasicMapperData GetElementMapperData(this IMemberMapperData mapperData)

AgileMapper/ObjectPopulation/IObjectMapper.cs

@@ -12,6 +12,8 @@ internal interface IObjectMapper : IObjectMapperFunc
 
         IEnumerable<IRecursionMapperFunc> RecursionMapperFuncs { get; }
 
+        void CacheRecursionMapperFuncs();
+
         bool IsStaticallyCacheable();
 
         void Reset();

AgileMapper/ObjectPopulation/MapperCreationCallbackKey.cs

@@ -6,8 +6,6 @@ namespace AgileObjects.AgileMapper.ObjectPopulation
 
     internal class MapperCreationCallbackKey
     {
-        public static readonly IEqualityComparer<MapperCreationCallbackKey> Comparer = new KeyComparer();
-
         private readonly MappingRuleSet _ruleSet;
         private readonly Type _sourceType;
         private readonly Type _targetType;
@@ -27,7 +25,7 @@ public MapperCreationCallbackKey(
             _targetType = targetType;
         }
 
-        private class KeyComparer : IEqualityComparer<MapperCreationCallbackKey>
+        public struct Comparer : IEqualityComparer<MapperCreationCallbackKey>
         {
             public bool Equals(MapperCreationCallbackKey x, MapperCreationCallbackKey y)
             {

AgileMapper/ObjectPopulation/MapperKeys/ObjectMapperKeyBase.cs

@@ -1,6 +1,5 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation.MapperKeys
 {
-    using Members;
     using Members.Sources;
 
     internal abstract class ObjectMapperKeyBase : SourceMemberTypeDependentKeyBase, ITypedMapperKey

AgileMapper/ObjectPopulation/MapperKeys/RootMapperKeyComparer.cs

@@ -11,6 +11,11 @@ public bool Equals(IRootMapperKey x, IRootMapperKey y)
             // ReSharper restore PossibleNullReferenceException
         }
 
+        #region ExcludeFromCodeCoverage
+#if DEBUG
+        [ExcludeFromCodeCoverage]
+#endif
+        #endregion
         public int GetHashCode(IRootMapperKey obj) => 0;
     }
 }

AgileMapper/ObjectPopulation/ObjectMapper.cs

@@ -40,18 +40,20 @@ public ObjectMapper(
 
             if (MapperData.HasMapperFuncs)
             {
-                _recursionMapperFuncsByKey = CreateRecursionMapperFuncsCache(mappingData);
+                _recursionMapperFuncsByKey = MapperData.MapperContext.Cache.CreateNew<ObjectMapperKeyBase, IRecursionMapperFunc>();
+                MapperData.Mapper = this;
+                
+                CacheRecursionMapperFuncs();
             }
         }
 
         #region Setup
 
-        private ICache<ObjectMapperKeyBase, IRecursionMapperFunc> CreateRecursionMapperFuncsCache(
-            IObjectMappingData mappingData)
+        public void CacheRecursionMapperFuncs()
         {
-            var cache = MapperData.MapperContext.Cache.CreateNew<ObjectMapperKeyBase, IRecursionMapperFunc>();
-
-            for (var i = 0; i < MapperData.RequiredMapperFuncKeys.Count; i++)
+            // Using a for loop here because creation of a recursion mapper func can
+            // cause additions to MapperData.RequiredMapperFuncKeys
+            for (var i = _recursionMapperFuncsByKey.Count; i < MapperData.RequiredMapperFuncKeys.Count; i++)
             {
                 var mapperKey = MapperData.RequiredMapperFuncKeys[i];
 
@@ -80,12 +82,10 @@ private ICache<ObjectMapperKeyBase, IRecursionMapperFunc> CreateRecursionMapperF
 
                 var mapperFunc = mapperFuncCreator.Invoke(
                     mapperKey.MappingData,
-                    mappingData.MappingContext.LazyLoadRecursionMappingFuncs);
+                    mapperKey.MappingData.MappingContext.LazyLoadRecursionMappingFuncs);
 
-                cache.GetOrAdd(mapperKey, k => mapperFunc);
+                _recursionMapperFuncsByKey.GetOrAdd(mapperKey, k => mapperFunc);
             }
-
-            return cache;
         }
 
         #endregion

AgileMapper/ObjectPopulation/ObjectMapperFactory.cs

@@ -37,7 +37,7 @@ public void RegisterCreationCallback(MapperCreationCallbackKey creationCallbackK
             if (_creationCallbacksByKey == null)
             {
                 _creationCallbacksByKey =
-                    new Dictionary<MapperCreationCallbackKey, Action<IObjectMapper>>(MapperCreationCallbackKey.Comparer);
+                    new Dictionary<MapperCreationCallbackKey, Action<IObjectMapper>>(default(MapperCreationCallbackKey.Comparer));
             }
 
             _creationCallbacksByKey.Add(creationCallbackKey, callback);