Making object tracking optional

Author: SteveWilkes

AgileMapper.UnitTests/Members/MemberTestsBase.cs

@@ -9,6 +9,7 @@
 
     public abstract class MemberTestsBase
     {
+        internal static readonly MapperContext DefaultMapperContext = new MapperContext();
         internal static readonly MemberFinder MemberFinder = GlobalContext.Instance.MemberFinder;
 
         internal IQualifiedMember SourceMemberFor<T>(T sourceObject)

AgileMapper.UnitTests/Members/WhenDeterminingRecursion.cs

@@ -10,7 +10,7 @@ public class WhenDeterminingRecursion : MemberTestsBase
         [Fact]
         public void ShouldNotCountARootMemberAsRecursive()
         {
-            var rootMember = new RootQualifiedMemberFactory(MapperContext.Default)
+            var rootMember = new RootQualifiedMemberFactory(DefaultMapperContext)
                 .RootTarget<PublicProperty<string>>();
 
             rootMember.IsRecursive.ShouldBeFalse();

AgileMapper.UnitTests/Members/WhenFindingDataSources.cs

@@ -13,7 +13,7 @@ public void ShouldNotMatchSameNameIncompatibleTypeProperties()
             var source = new TwoValues { Value = new int[5], value = string.Empty };
             var targetMember = TargetMemberFor<PublicProperty<byte>>(x => x.Value);
 
-            var mappingContext = new MappingExecutor<TwoValues>(new MappingRuleSetCollection().CreateNew, MapperContext.Default);
+            var mappingContext = new MappingExecutor<TwoValues>(new MappingRuleSetCollection().CreateNew, DefaultMapperContext);
             var rootMappingData = mappingContext.CreateRootMappingData(source, targetMember);
             var rootMapperData = rootMappingData.MapperData;
 

AgileMapper.UnitTests/WhenMappingCircularReferences.cs

@@ -200,6 +200,20 @@ public void ShouldShowMapElementCalls()
             plan.ShouldContain("products.Add(oaToPsData.Map(objectArray[i]");
         }
 
+        [Fact]
+        public void ShouldShowObjectTracking()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping.TrackMappedObjects();
+
+                var plan = mapper.GetPlanFor<Parent>().ToANew<Parent>();
+
+                plan.ShouldContain("pToPData.TryGet(sourceChild.EldestParent, out parent)");
+                plan.ShouldContain("pToPData.Register(sourceChild.EldestParent, parent)");
+            }
+        }
+
         [Fact]
         public void ShouldNotDuplicateChildMappingPlans()
         {

AgileMapper.UnitTests/WhenViewingMappingPlans.cs

@@ -36,6 +36,16 @@ public interface IFullMappingConfigurator<TSource, TTarget> : IConditionalMappin
         /// </param>
         void PassExceptionsTo(Action<IMappingExceptionData<TSource, TTarget>> callback);
 
+        /// <summary>
+        /// Configure this mapper to keep track of objects during a mapping in order to short-circuit 
+        /// circular relationships and ensure a 1-to-1 relationship between source and mapped objects.
+        /// </summary>
+        /// <returns>
+        /// A MappingConfigContinuation to enable further configuration of mappings from and to the source and 
+        /// target type being configured.
+        /// </returns>
+        MappingConfigContinuation<TSource, TTarget> TrackMappedObjects();
+
         /// <summary>
         /// Configure a derived target type to which to map instances of the given derived source type.
         /// </summary>

AgileMapper/Api/Configuration/IFullMappingConfigurator.cs

@@ -169,6 +169,17 @@ private void UseNamePatterns(IEnumerable<string> patterns)
 
         #endregion
 
+        #region Object Equality
+
+        /// <summary>
+        /// Configure this mapper to keep track of objects during a mapping in order to short-circuit 
+        /// circular relationships and ensure a 1-to-1 relationship between source and mapped objects.
+        /// </summary>
+        public void TrackMappedObjects()
+            => _mapperContext.UserConfigurations.Add(ObjectTrackingMode.TrackAll(_mapperContext));
+
+        #endregion
+
         /// <summary>
         /// Configure how this mapper maps objects of the type specified by the type argument.
         /// </summary>

AgileMapper/Api/Configuration/MappingConfigStartingPoint.cs

@@ -56,6 +56,15 @@ public void PassExceptionsTo(Action<IMappingExceptionData<TSource, TTarget>> cal
             _configInfo.MapperContext.UserConfigurations.Add(exceptionCallback);
         }
 
+        public MappingConfigContinuation<TSource, TTarget> TrackMappedObjects()
+        {
+            var trackingMode = new ObjectTrackingMode(_configInfo.ForTargetType<TTarget>());
+
+            _configInfo.MapperContext.UserConfigurations.Add(trackingMode);
+
+            return new MappingConfigContinuation<TSource, TTarget>(_configInfo);
+        }
+
         public MappingConfigContinuation<TSource, TTarget> Ignore(params Expression<Func<TTarget, object>>[] targetMembers)
         {
             var configInfo = _configInfo.ForTargetType<TTarget>();

AgileMapper/Api/Configuration/MappingConfigurator.cs

@@ -2,6 +2,17 @@ namespace AgileObjects.AgileMapper.Configuration
 {
     using System.Linq.Expressions;
 
+    internal class ObjectTrackingMode : UserConfiguredItemBase
+    {
+        public ObjectTrackingMode(MappingConfigInfo configInfo)
+            : base(configInfo)
+        {
+        }
+
+        public static ObjectTrackingMode TrackAll(MapperContext mapperContext)
+            => new ObjectTrackingMode(MappingConfigInfo.AllRuleSetsSourceTypesAndTargetTypes(mapperContext));
+    }
+
     internal class ConfiguredIgnoredMember : UserConfiguredItemBase
     {
         public ConfiguredIgnoredMember(MappingConfigInfo configInfo, LambdaExpression targetMemberLambda)

AgileMapper/Configuration/ConfiguredIgnoredMember.cs

@@ -11,6 +11,7 @@
 
     internal class UserConfigurationSet
     {
+        private readonly ICollection<ObjectTrackingMode> _trackingModeSettings;
         private readonly ICollection<ConfiguredObjectFactory> _objectFactories;
         private readonly ICollection<ConfiguredIgnoredMember> _ignoredMembers;
         private readonly ICollection<ConfiguredDataSourceFactory> _dataSourceFactories;
@@ -20,6 +21,7 @@ internal class UserConfigurationSet
 
         public UserConfigurationSet()
         {
+            _trackingModeSettings = new List<ObjectTrackingMode>();
             _objectFactories = new List<ConfiguredObjectFactory>();
             Identifiers = new MemberIdentifierSet();
             _ignoredMembers = new List<ConfiguredIgnoredMember>();
@@ -30,6 +32,23 @@ public UserConfigurationSet()
             DerivedTypes = new DerivedTypePairSet();
         }
 
+        #region Tracking Modes
+
+        public void Add(ObjectTrackingMode trackingMode) => _trackingModeSettings.Add(trackingMode);
+
+        public bool DisableObjectTracking(IBasicMapperData basicData)
+        {
+            if (_trackingModeSettings.None())
+            {
+                // Object tracking switched off by default:
+                return true;
+            }
+
+            return _trackingModeSettings.All(tm => !tm.AppliesTo(basicData));
+        }
+
+        #endregion
+
         #region ObjectFactories
 
         public void Add(ConfiguredObjectFactory objectFactory) => _objectFactories.Add(objectFactory);