From f149a39410524595b39258904d03c50c52be4dcc Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Mon, 16 Oct 2017 22:16:42 +0100
Subject: [PATCH 1/8] Switching from MappingTypes.Fixed() to
 MappingTypes<>.Fixed

---
 AgileMapper/MappingExecutor.cs                |  2 +-
 AgileMapper/Members/MappingTypes.cs           | 32 +++++++++----------
 .../ObjectPopulation/MappingDataFactory.cs    |  4 +--
 3 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/AgileMapper/MappingExecutor.cs b/AgileMapper/MappingExecutor.cs
index 460d81d6b..177c6f132 100644
--- a/AgileMapper/MappingExecutor.cs
+++ b/AgileMapper/MappingExecutor.cs
@@ -68,7 +68,7 @@ private ObjectMappingData<TSource, TTarget> CreateTypedRootMappingData<TTarget>(
                 _source,
                 target,
                 null, // <- No enumerable index because we're at the root
-                new RootObjectMapperKey(MappingTypes.Fixed<TSource, TTarget>(), this),
+                new RootObjectMapperKey(MappingTypes<TSource, TTarget>.Fixed, this),
                 this,
                 parent: null);
         }
diff --git a/AgileMapper/Members/MappingTypes.cs b/AgileMapper/Members/MappingTypes.cs
index c3982fd71..22d226a50 100644
--- a/AgileMapper/Members/MappingTypes.cs
+++ b/AgileMapper/Members/MappingTypes.cs
@@ -6,7 +6,7 @@ namespace AgileObjects.AgileMapper.Members
 
     internal class MappingTypes
     {
-        private MappingTypes(
+        public MappingTypes(
             Type sourceType,
             Type targetType,
             bool runtimeTypesAreTheSame,
@@ -20,13 +20,11 @@ private MappingTypes(
 
         #region Factory Method
 
-        public static MappingTypes Fixed<TSource, TTarget>() => MappingTypesCache<TSource, TTarget>.Instance;
-
         public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
         {
-            if (MappingTypesCache<TSource, TTarget>.SkipTypesCheck)
+            if (MappingTypes<TSource, TTarget>.SkipTypesCheck)
             {
-                return Fixed<TSource, TTarget>();
+                return MappingTypes<TSource, TTarget>.Fixed;
             }
 
             var runtimeSourceTypeNeeded = TypeInfo<TSource>.RuntimeTypeNeeded;
@@ -78,7 +76,7 @@ public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
 
             if (!runtimeTypesNeeded)
             {
-                return Fixed<TSource, TTarget>();
+                return MappingTypes<TSource, TTarget>.Fixed;
             }
 
             var isEnumerable = TypeInfo<TTarget>.IsEnumerable ||
@@ -121,17 +119,17 @@ public MappingTypes WithTypes<TNewSource, TNewTarget>()
                 RuntimeTypesAreTheSame,
                 IsEnumerable);
         }
+    }
 
-        private static class MappingTypesCache<TSource, TTarget>
-        {
-            public static readonly bool SkipTypesCheck =
-                !(TypeInfo<TSource>.RuntimeTypeNeeded || TypeInfo<TTarget>.RuntimeTypeNeeded);
-
-            public static readonly MappingTypes Instance = new MappingTypes(
-                typeof(TSource),
-                typeof(TTarget),
-                true, // <- runtimeTypesAreTheSame
-                TypeInfo<TTarget>.IsEnumerable);
-        }
+    internal static class MappingTypes<TSource, TTarget>
+    {
+        public static readonly bool SkipTypesCheck =
+            !(TypeInfo<TSource>.RuntimeTypeNeeded || TypeInfo<TTarget>.RuntimeTypeNeeded);
+
+        public static readonly MappingTypes Fixed = new MappingTypes(
+            typeof(TSource),
+            typeof(TTarget),
+            true, // <- runtimeTypesAreTheSame
+            TypeInfo<TTarget>.IsEnumerable);
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/ObjectPopulation/MappingDataFactory.cs b/AgileMapper/ObjectPopulation/MappingDataFactory.cs
index a90474b89..633ce04fd 100644
--- a/AgileMapper/ObjectPopulation/MappingDataFactory.cs
+++ b/AgileMapper/ObjectPopulation/MappingDataFactory.cs
@@ -25,7 +25,7 @@ public static ObjectMappingData<TSource, TTarget> ForChild<TSource, TTarget>(
             var mapperKey = new ChildObjectMapperKey(
                 targetMemberRegistrationName,
                 dataSourceIndex,
-                MappingTypes.Fixed<TSource, TTarget>());
+                MappingTypes<TSource, TTarget>.Fixed);
 
             var mappingData = CreateMappingData(source, target, enumerableIndex, mapperKey, parent);
 
@@ -53,7 +53,7 @@ public static ObjectMappingData<TSourceElement, TTargetElement> ForElement<TSour
             int enumerableIndex,
             IObjectMappingDataUntyped parent)
         {
-            var mapperKey = new ElementObjectMapperKey(MappingTypes.Fixed<TSourceElement, TTargetElement>());
+            var mapperKey = new ElementObjectMapperKey(MappingTypes<TSourceElement, TTargetElement>.Fixed);
 
             var mappingData = CreateMappingData(sourceElement, targetElement, enumerableIndex, mapperKey, parent);
 

From f5c03b005a6b3f4d4cbe43975b17f04dc71667fa Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Fri, 20 Oct 2017 11:14:36 +0100
Subject: [PATCH 2/8] Support for accessing mapping plans for anonymous sources
 and user-defined struct mappings

---
 .../WhenViewingMappingPlans.cs                | 63 +++++++++++++++++++
 AgileMapper/Api/PlanTargetTypeSelector.cs     |  6 +-
 AgileMapper/IMapper.cs                        | 14 +++++
 AgileMapper/Mapper.cs                         | 16 +++++
 4 files changed, 96 insertions(+), 3 deletions(-)

diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index 08b82bb6c..921691dc8 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -19,6 +19,69 @@ public void ShouldIncludeASimpleTypeMemberMapping()
             plan.ShouldContain("publicProperty_String.Value = pfsToPpsData.Source.Value;");
         }
 
+        [Fact]
+        public void ShouldSupportAnonymousSourceTypesFromTheStaticApi()
+        {
+            var plan = Mapper
+                .GetPlanFor(new { Name = default(string), Discount = default(int) })
+                .ToANew<MysteryCustomer>();
+
+            plan.ShouldContain("Map AnonymousType<string, int> -> MysteryCustomer");
+            plan.ShouldContain("mysteryCustomer.Name = fatsiToMcData.Source.Name;");
+            plan.ShouldContain("mysteryCustomer.Discount = (decimal)fatsiToMcData.Source.Discount;");
+            plan.ShouldContain("// No data source for Report");
+        }
+
+        [Fact]
+        public void ShouldSupportAnonymousSourceTypesFromTheInstanceApi()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var plan = mapper
+                    .GetPlanFor(new { Name = default(string), AddressLine1 = default(string) })
+                    .OnTo<Customer>();
+
+                plan.ShouldContain("Map AnonymousType<string, string> -> Customer");
+                plan.ShouldContain("customer.Name = sourceF__AnonymousType29_String_String.Name;");
+                plan.ShouldContain("address.Line1 = sourceF__AnonymousType29_String_String.AddressLine1;");
+            }
+        }
+
+        [Fact]
+        public void ShouldSupportStructsFromTheStaticApi()
+        {
+            var plan = Mapper
+                .GetPlanFor<PublicTwoFieldsStruct<int, int>>()
+                .Over<PublicTwoFieldsStruct<string, string>>();
+
+            plan.ShouldContain("publicTwoFieldsStruct_String_String.Value1 = ptfsiiToPtfsssData.Source.Value1.ToString();");
+        }
+
+        [Fact]
+        public void ShouldSupportStructMergePlansFromTheStaticApi()
+        {
+            var plan = Mapper
+                .GetPlanFor<PublicTwoFieldsStruct<int, int>>()
+                .OnTo<PublicTwoFieldsStruct<string, string>>();
+
+            plan.ShouldContain("publicTwoFieldsStruct_String_String.Value1 = ptfsiiToPtfsssData.Source.Value1.ToString();");
+        }
+
+        [Fact]
+        public void ShouldSupportStructsFromTheInstanceApi()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var plan = mapper
+                    .GetPlanFor<PublicPropertyStruct<string>>()
+                    .ToANew<PublicCtorStruct<string>>();
+
+                plan.ShouldContain("Map PublicPropertyStruct<string> -> PublicCtorStruct<string>");
+                plan.ShouldContain("return new PublicCtorStruct");
+                plan.ShouldContain("ppssToPcssData.Source.Value");
+            }
+        }
+
         [Fact]
         public void ShouldIncludeAComplexTypeMemberMapping()
         {
diff --git a/AgileMapper/Api/PlanTargetTypeSelector.cs b/AgileMapper/Api/PlanTargetTypeSelector.cs
index e8d48a16e..159addd3d 100644
--- a/AgileMapper/Api/PlanTargetTypeSelector.cs
+++ b/AgileMapper/Api/PlanTargetTypeSelector.cs
@@ -22,7 +22,7 @@ internal PlanTargetTypeSelector(MapperContext mapperContext)
         /// </summary>
         /// <typeparam name="TResult">The type of object for which to create the mapping plans.</typeparam>
         /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        public string ToANew<TResult>() where TResult : class
+        public string ToANew<TResult>()
             => GetMappingPlan<TResult>(_mapperContext.RuleSets.CreateNew);
 
         /// <summary>
@@ -31,7 +31,7 @@ public string ToANew<TResult>() where TResult : class
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
         /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        public string OnTo<TTarget>() where TTarget : class
+        public string OnTo<TTarget>()
             => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Merge);
 
         /// <summary>
@@ -40,7 +40,7 @@ public string OnTo<TTarget>() where TTarget : class
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
         /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        public string Over<TTarget>() where TTarget : class
+        public string Over<TTarget>()
             => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Overwrite);
 
         private string GetMappingPlan<TTarget>(MappingRuleSet ruleSet)
diff --git a/AgileMapper/IMapper.cs b/AgileMapper/IMapper.cs
index 9f52404eb..5093f6f81 100644
--- a/AgileMapper/IMapper.cs
+++ b/AgileMapper/IMapper.cs
@@ -15,6 +15,20 @@ public interface IMapper : IDisposable
         /// <returns>A cloned copy of this mapper.</returns>
         IMapper CloneSelf();
 
+        /// <summary>
+        /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
+        /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the given <paramref name="exampleInstance"/>.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
+        /// be cached.
+        /// </returns>
+        PlanTargetTypeSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance);
+
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
         /// specified by the type argument.
diff --git a/AgileMapper/Mapper.cs b/AgileMapper/Mapper.cs
index d258f4d18..617a37ed3 100644
--- a/AgileMapper/Mapper.cs
+++ b/AgileMapper/Mapper.cs
@@ -28,6 +28,8 @@ private Mapper(MapperContext mapperContext)
 
         #endregion
 
+        PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
+
         PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
             => new PlanTargetTypeSelector<TSource>(_mapperContext);
 
@@ -37,6 +39,20 @@ PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
 
         #region Static Access Methods
 
+        /// <summary>
+        /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
+        /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the given <paramref name="exampleInstance"/>.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
+        /// be cached.
+        /// </returns>
+        public static PlanTargetTypeSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
+
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
         /// specified by the type argument.

From 287d17255dd140367959e1a041e4192906c4efa8 Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Fri, 20 Oct 2017 11:57:23 +0100
Subject: [PATCH 3/8] Adding Mapper.GetPlansFor() to generate and cache mapping
 plans for a type pair for all rule sets in one call

---
 .../WhenViewingMappingPlans.cs                | 12 +++++
 .../Api/IPlanTargetTypeAndRuleSetSelector.cs  | 33 +++++++++++++
 AgileMapper/Api/IPlanTargetTypeSelector.cs    | 17 +++++++
 AgileMapper/Api/PlanTargetTypeSelector.cs     | 48 +++++++------------
 AgileMapper/IMapper.cs                        | 23 ++++++---
 AgileMapper/Mapper.cs                         | 31 ++++++++----
 AgileMapper/MappingRuleSetCollection.cs       |  2 +
 AgileMapper/Plans/MappingPlanSet.cs           | 23 +++++++++
 8 files changed, 145 insertions(+), 44 deletions(-)
 create mode 100644 AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
 create mode 100644 AgileMapper/Api/IPlanTargetTypeSelector.cs
 create mode 100644 AgileMapper/Plans/MappingPlanSet.cs

diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index 921691dc8..75684b85b 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -19,6 +19,18 @@ public void ShouldIncludeASimpleTypeMemberMapping()
             plan.ShouldContain("publicProperty_String.Value = pfsToPpsData.Source.Value;");
         }
 
+        [Fact]
+        public void ShouldGenerateAllRuleSets()
+        {
+            Mapper
+                .GetPlansFor<PublicField<string>>()
+                .To<PublicProperty<string>>();
+
+            //plan.ShouldContain("Rule Set: CreateNew");
+            //plan.ShouldContain("Rule Set: Merge");
+            //plan.ShouldContain("Rule Set: Overwrite");
+        }
+
         [Fact]
         public void ShouldSupportAnonymousSourceTypesFromTheStaticApi()
         {
diff --git a/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
new file mode 100644
index 000000000..9fcfaa19d
--- /dev/null
+++ b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
@@ -0,0 +1,33 @@
+namespace AgileObjects.AgileMapper.Api
+{
+    /// <summary>
+    /// Provides options to create and compile mapping functions for a particular type of mapping from the 
+    /// source type being configured to a specified target type.
+    /// </summary>
+    public interface IPlanTargetTypeAndRuleSetSelector
+    {
+        /// <summary>
+        /// Create and compile mapping functions for a create new mapping from the source type being 
+        /// configured to the type specified by the type argument.
+        /// </summary>
+        /// <typeparam name="TResult">The type of object for which to create the mapping plan.</typeparam>
+        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
+        string ToANew<TResult>();
+
+        /// <summary>
+        /// Create and compile mapping functions for an OnTo (merge) mapping from the source type being 
+        /// configured to the type specified by the type argument.
+        /// </summary>
+        /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
+        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
+        string OnTo<TTarget>();
+
+        /// <summary>
+        /// Create and compile mapping functions for an Over (overwrite) mapping from the source type being 
+        /// configured to the type specified by the type argument.
+        /// </summary>
+        /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
+        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
+        string Over<TTarget>();
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Api/IPlanTargetTypeSelector.cs b/AgileMapper/Api/IPlanTargetTypeSelector.cs
new file mode 100644
index 000000000..55f6611f9
--- /dev/null
+++ b/AgileMapper/Api/IPlanTargetTypeSelector.cs
@@ -0,0 +1,17 @@
+namespace AgileObjects.AgileMapper.Api
+{
+    /// <summary>
+    /// Provides the option to create and compile mapping functions for mappings from the source type 
+    /// being configured to a specified target type, for all mapping types (create new, merge, overwrite).
+    /// </summary>
+    public interface IPlanTargetTypeSelector
+    {
+        /// <summary>
+        /// Create and compile mapping functions from the source type being configured to the type specified 
+        /// by the type argument, for all mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
+        /// <returns>A set of string mapping plans showing the functions to be executed during a mapping.</returns>
+        string To<TTarget>();
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Api/PlanTargetTypeSelector.cs b/AgileMapper/Api/PlanTargetTypeSelector.cs
index 159addd3d..f4e7dc99a 100644
--- a/AgileMapper/Api/PlanTargetTypeSelector.cs
+++ b/AgileMapper/Api/PlanTargetTypeSelector.cs
@@ -1,52 +1,40 @@
 namespace AgileObjects.AgileMapper.Api
 {
+    using System.Linq;
     using Plans;
 
-    /// <summary>
-    /// Provides options to create and compile mapping functions for a particular type of mapping from the 
-    /// source type being configured to a specified target type.
-    /// </summary>
-    /// <typeparam name="TSource">The source type to which the configuration should apply.</typeparam>
-    public class PlanTargetTypeSelector<TSource>
+    internal class PlanTargetTypeSelector<TSource> : IPlanTargetTypeSelector, IPlanTargetTypeAndRuleSetSelector
     {
         private readonly MapperContext _mapperContext;
 
         internal PlanTargetTypeSelector(MapperContext mapperContext)
         {
             _mapperContext = mapperContext;
+        }
+
+        public string To<TTarget>()
+        {
+            return new MappingPlanSet<TSource, TTarget>(
+                _mapperContext
+                    .RuleSets
+                    .All
+                    .Select(GetMappingPlan<TTarget>)
+                    .ToArray());
         }
 
-        /// <summary>
-        /// Create and compile mapping functions for a create new mapping from the source type being 
-        /// configured to the type specified by the type argument.
-        /// </summary>
-        /// <typeparam name="TResult">The type of object for which to create the mapping plans.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
         public string ToANew<TResult>()
-            => GetMappingPlan<TResult>(_mapperContext.RuleSets.CreateNew);
-
-        /// <summary>
-        /// Create and compile mapping functions for an OnTo (merge) mapping from the source type being 
-        /// configured to the type specified by the type argument.
-        /// </summary>
-        /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
+            => GetMappingPlan<TResult>(_mapperContext.RuleSets.CreateNew);
+
         public string OnTo<TTarget>()
-            => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Merge);
-
-        /// <summary>
-        /// Create and compile mapping functions for an Over (overwrite) mapping from the source type being 
-        /// configured to the type specified by the type argument.
-        /// </summary>
-        /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
+            => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Merge);
+
         public string Over<TTarget>()
             => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Overwrite);
 
-        private string GetMappingPlan<TTarget>(MappingRuleSet ruleSet)
+        private MappingPlan<TSource, TTarget> GetMappingPlan<TTarget>(MappingRuleSet ruleSet)
         {
             var planContext = new MappingExecutor<TSource>(ruleSet, _mapperContext);
-
+
             return new MappingPlan<TSource, TTarget>(planContext);
         }
     }
diff --git a/AgileMapper/IMapper.cs b/AgileMapper/IMapper.cs
index 5093f6f81..bb6218c49 100644
--- a/AgileMapper/IMapper.cs
+++ b/AgileMapper/IMapper.cs
@@ -15,6 +15,17 @@ public interface IMapper : IDisposable
         /// <returns>A cloned copy of this mapper.</returns>
         IMapper CloneSelf();
 
+        /// <summary>
+        /// Create and compile mapping functions for the source type specified by the type argument, for all
+        /// mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        IPlanTargetTypeSelector GetPlansFor<TSource>();
+
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
         /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
@@ -24,10 +35,10 @@ public interface IMapper : IDisposable
         /// An instance specifying the source type for which a mapping plan should be created.
         /// </param>
         /// <returns>
-        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
-        /// be cached.
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
         /// </returns>
-        PlanTargetTypeSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance);
+        IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>(TSource exampleInstance);
 
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
@@ -35,10 +46,10 @@ public interface IMapper : IDisposable
         /// </summary>
         /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
         /// <returns>
-        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
-        /// be cached.
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
         /// </returns>
-        PlanTargetTypeSelector<TSource> GetPlanFor<TSource>();
+        IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>();
 
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
diff --git a/AgileMapper/Mapper.cs b/AgileMapper/Mapper.cs
index 617a37ed3..680796358 100644
--- a/AgileMapper/Mapper.cs
+++ b/AgileMapper/Mapper.cs
@@ -28,9 +28,13 @@ private Mapper(MapperContext mapperContext)
 
         #endregion
 
-        PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
+        IPlanTargetTypeSelector IMapper.GetPlansFor<TSource>() => GetPlan<TSource>();
 
-        PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
+        IPlanTargetTypeAndRuleSetSelector IMapper.GetPlanFor<TSource>(TSource exampleInstance) => GetPlan<TSource>();
+
+        IPlanTargetTypeAndRuleSetSelector IMapper.GetPlanFor<TSource>() => GetPlan<TSource>();
+
+        private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
             => new PlanTargetTypeSelector<TSource>(_mapperContext);
 
         PreEventConfigStartingPoint IMapper.Before => new PreEventConfigStartingPoint(_mapperContext);
@@ -39,6 +43,17 @@ PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
 
         #region Static Access Methods
 
+        /// <summary>
+        /// Create and compile mapping functions for the source type specified by the type argument, for all
+        /// mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        public static IPlanTargetTypeSelector GetPlansFor<TSource>() => _default.GetPlansFor<TSource>();
+
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
         /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
@@ -48,10 +63,10 @@ PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
         /// An instance specifying the source type for which a mapping plan should be created.
         /// </param>
         /// <returns>
-        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
-        /// be cached.
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
         /// </returns>
-        public static PlanTargetTypeSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
+        public static IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
 
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
@@ -59,10 +74,10 @@ PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
         /// </summary>
         /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
         /// <returns>
-        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
-        /// be cached.
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
         /// </returns>
-        public static PlanTargetTypeSelector<TSource> GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
+        public static IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
 
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
diff --git a/AgileMapper/MappingRuleSetCollection.cs b/AgileMapper/MappingRuleSetCollection.cs
index f9e53f80c..47d619d01 100644
--- a/AgileMapper/MappingRuleSetCollection.cs
+++ b/AgileMapper/MappingRuleSetCollection.cs
@@ -40,6 +40,8 @@ public MappingRuleSetCollection()
             _ruleSets = new List<MappingRuleSet> { CreateNew, Merge, Overwrite };
         }
 
+        public IEnumerable<MappingRuleSet> All => _ruleSets;
+
         public MappingRuleSet CreateNew => _createNew;
 
         public MappingRuleSet Merge => _merge;
diff --git a/AgileMapper/Plans/MappingPlanSet.cs b/AgileMapper/Plans/MappingPlanSet.cs
new file mode 100644
index 000000000..9292eec3f
--- /dev/null
+++ b/AgileMapper/Plans/MappingPlanSet.cs
@@ -0,0 +1,23 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    internal class MappingPlanSet<TSource, TTarget>
+    {
+        private readonly IEnumerable<MappingPlan<TSource, TTarget>> _mappingPlans;
+
+        public MappingPlanSet(IEnumerable<MappingPlan<TSource, TTarget>> mappingPlans)
+        {
+            _mappingPlans = mappingPlans;
+        }
+
+        public static implicit operator string(MappingPlanSet<TSource, TTarget> mappingPlans)
+        {
+            return string.Join(
+                Environment.NewLine + Environment.NewLine,
+                mappingPlans._mappingPlans.Select(plan => (string)plan));
+        }
+    }
+}
\ No newline at end of file

From 5e04bc8cf6717d1a20e6325d6494377b3d671773 Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Fri, 20 Oct 2017 12:14:31 +0100
Subject: [PATCH 4/8] Re-instating test asserts

---
 AgileMapper.UnitTests/WhenViewingMappingPlans.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index 75684b85b..811c8ef07 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -22,13 +22,13 @@ public void ShouldIncludeASimpleTypeMemberMapping()
         [Fact]
         public void ShouldGenerateAllRuleSets()
         {
-            Mapper
+            var plan = Mapper
                 .GetPlansFor<PublicField<string>>()
                 .To<PublicProperty<string>>();
 
-            //plan.ShouldContain("Rule Set: CreateNew");
-            //plan.ShouldContain("Rule Set: Merge");
-            //plan.ShouldContain("Rule Set: Overwrite");
+            plan.ShouldContain("Rule Set: CreateNew");
+            plan.ShouldContain("Rule Set: Merge");
+            plan.ShouldContain("Rule Set: Overwrite");
         }
 
         [Fact]

From cee732915dbdd62a239d03d3e54e081d5f643afc Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Fri, 20 Oct 2017 15:29:13 +0100
Subject: [PATCH 5/8] Test coverage for unmappable members appearing in test
 plans

---
 .../WhenViewingMappingPlans.cs                | 72 +++++++++++++++++++
 AgileMapper/Members/MemberExtensions.cs       |  2 +-
 2 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index 811c8ef07..67437d259 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Collections.ObjectModel;
     using System.Text.RegularExpressions;
     using Shouldly;
     using TestClasses;
@@ -412,5 +413,76 @@ public void ShouldIncludeMemberFilterExpressions()
                 plan.ShouldContain("member.IsPropertyMatching(p => p.Name == \"Line2\")");
             }
         }
+
+        [Fact]
+        public void ShouldIncludeUnmappableStructComplexTypeMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var plan = mapper
+                    .GetPlanFor<PublicTwoFields<Person, string>>()
+                    .ToANew<PublicTwoFieldsStruct<Person, int>>();
+
+                plan.ShouldContain("int.TryParse(ptfpsToPtfspiData.Source.Value2");
+                plan.ShouldContain("Person member on a struct");
+            }
+        }
+
+        [Fact]
+        public void ShouldIncludeUnmappableReadOnlyArrayMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<string[]>>()
+                    .To<PublicReadOnlyField<int[]>>()
+                    .Map(ctx => ctx.Source.Value)
+                    .ToCtor<int[]>();
+
+                var plan = mapper
+                    .GetPlanFor<PublicField<string[]>>()
+                    .ToANew<PublicReadOnlyField<int[]>>();
+
+                plan.ShouldContain("readonly array");
+            }
+        }
+
+        [Fact]
+        public void ShouldIncludeUnmappableReadOnlyReadOnlyCollectionMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<string[]>>()
+                    .To<PublicReadOnlyField<ReadOnlyCollection<int>>>()
+                    .Map(ctx => ctx.Source.Value)
+                    .ToCtor("readOnlyValue");
+
+                var plan = mapper
+                    .GetPlanFor<PublicField<string[]>>()
+                    .ToANew<PublicReadOnlyField<ReadOnlyCollection<int>>>();
+
+                plan.ShouldContain("readonly ReadOnlyCollection<int>");
+            }
+        }
+
+        [Fact]
+        public void ShouldIncludeUnmappableReadOnlyIntMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<string>>()
+                    .To<PublicReadOnlyField<int>>()
+                    .Map(ctx => ctx.Source.Value)
+                    .ToCtor("readOnlyValue");
+
+                var plan = mapper
+                    .GetPlanFor<PublicField<string>>()
+                    .ToANew<PublicReadOnlyField<int>>();
+
+                plan.ShouldContain("readonly int");
+            }
+        }
     }
 }
diff --git a/AgileMapper/Members/MemberExtensions.cs b/AgileMapper/Members/MemberExtensions.cs
index a85a27a62..b07f347cf 100644
--- a/AgileMapper/Members/MemberExtensions.cs
+++ b/AgileMapper/Members/MemberExtensions.cs
@@ -92,7 +92,7 @@ public static bool IsUnmappable(this QualifiedMember member, out string reason)
                 member.Type.IsGenericType() &&
                (member.Type.GetGenericTypeDefinition() == typeof(ReadOnlyCollection<>)))
             {
-                reason = "readonly ReadOnlyCollection";
+                reason = "readonly " + member.Type.GetFriendlyName();
                 return true;
             }
 

From 3689f8aaf5d1e55e3271f8cdc970281cbc15ce7f Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Fri, 20 Oct 2017 15:43:41 +0100
Subject: [PATCH 6/8] Returning MappingPlan objects from GetPlanFor().To()
 methods to avoid the overhead of creating the plan string if all the caller
 wants to do is cache

---
 .../WhenConfiguringEnumMapping.cs             |  2 +-
 .../WhenViewingDictionaryMappingPlans.cs      |  8 +--
 .../WhenMappingCircularReferences.cs          |  4 +-
 .../WhenViewingMappingPlans.cs                | 68 +++++++++----------
 .../Api/IPlanTargetTypeAndRuleSetSelector.cs  | 28 ++++++--
 AgileMapper/Api/IPlanTargetTypeSelector.cs    | 12 +++-
 AgileMapper/Api/PlanTargetTypeSelector.cs     | 10 +--
 AgileMapper/IMapper.cs                        |  6 +-
 AgileMapper/Mapper.cs                         | 12 ++--
 AgileMapper/Plans/MappingPlan.cs              | 27 +++++++-
 AgileMapper/Plans/MappingPlanSet.cs           | 30 +++++++-
 11 files changed, 138 insertions(+), 69 deletions(-)

diff --git a/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs b/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs
index 11e4f85da..cf95a09eb 100644
--- a/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs
+++ b/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs
@@ -36,7 +36,7 @@ public void ShouldRemovePairedEnumsFromEnumMismatchWarnings()
                 mapper.WhenMapping
                     .PairEnum(PaymentTypeUk.Cheque).With(PaymentTypeUs.Check);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicTwoFields<PaymentTypeUk, PaymentTypeUs>>()
                     .OnTo<PublicTwoFields<PaymentTypeUs, PaymentTypeUk>>();
 
diff --git a/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs b/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs
index a74d8717e..54d81176a 100644
--- a/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs
+++ b/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs
@@ -11,7 +11,7 @@ public class WhenViewingDictionaryMappingPlans
         [Fact]
         public void ShouldShowATargetObjectMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<Dictionary<string, string>>()
                 .ToANew<CustomerViewModel>();
 
@@ -25,7 +25,7 @@ public void ShouldShowATargetObjectMappingPlan()
         [Fact]
         public void ShouldShowATargetComplexTypeCollectionMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<Dictionary<string, object>>()
                 .ToANew<Collection<Address>>();
 
@@ -39,7 +39,7 @@ public void ShouldShowATargetComplexTypeCollectionMappingPlan()
         [Fact]
         public void ShouldShowASourceObjectMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<MysteryCustomer>()
                 .ToANew<Dictionary<string, object>>();
 
@@ -51,7 +51,7 @@ public void ShouldShowASourceObjectMappingPlan()
         [Fact]
         public void ShouldShowASourceComplexTypeEnumerableMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<IEnumerable<CustomerViewModel>>()
                 .ToANew<Dictionary<string, string>>();
 
diff --git a/AgileMapper.UnitTests/WhenMappingCircularReferences.cs b/AgileMapper.UnitTests/WhenMappingCircularReferences.cs
index 2bf841df6..ac419949c 100644
--- a/AgileMapper.UnitTests/WhenMappingCircularReferences.cs
+++ b/AgileMapper.UnitTests/WhenMappingCircularReferences.cs
@@ -307,7 +307,7 @@ public void ShouldMapNestedMultiplyRecursiveRelationships()
         [Fact]
         public void ShouldGenerateAMappingPlanForLinkRelationships()
         {
-            var plan = Mapper.GetPlanFor<Video>().Over<Video>();
+            string plan = Mapper.GetPlanFor<Video>().Over<Video>();
 
             plan.ShouldNotBeNull();
             plan.ShouldContain("WhenMappingCircularReferences.Video -> WhenMappingCircularReferences.Video");
@@ -317,7 +317,7 @@ public void ShouldGenerateAMappingPlanForLinkRelationships()
         [Fact]
         public void ShouldGenerateAMappingPlanForAOneToOneRelationship()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<Parent>()
                 .ToANew<Parent>();
 
diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index 67437d259..e02311455 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -13,7 +13,7 @@ public class WhenViewingMappingPlans
         [Fact]
         public void ShouldIncludeASimpleTypeMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicField<string>>()
                 .ToANew<PublicProperty<string>>();
 
@@ -23,7 +23,7 @@ public void ShouldIncludeASimpleTypeMemberMapping()
         [Fact]
         public void ShouldGenerateAllRuleSets()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlansFor<PublicField<string>>()
                 .To<PublicProperty<string>>();
 
@@ -35,7 +35,7 @@ public void ShouldGenerateAllRuleSets()
         [Fact]
         public void ShouldSupportAnonymousSourceTypesFromTheStaticApi()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor(new { Name = default(string), Discount = default(int) })
                 .ToANew<MysteryCustomer>();
 
@@ -50,7 +50,7 @@ public void ShouldSupportAnonymousSourceTypesFromTheInstanceApi()
         {
             using (var mapper = Mapper.CreateNew())
             {
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor(new { Name = default(string), AddressLine1 = default(string) })
                     .OnTo<Customer>();
 
@@ -63,7 +63,7 @@ public void ShouldSupportAnonymousSourceTypesFromTheInstanceApi()
         [Fact]
         public void ShouldSupportStructsFromTheStaticApi()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicTwoFieldsStruct<int, int>>()
                 .Over<PublicTwoFieldsStruct<string, string>>();
 
@@ -73,7 +73,7 @@ public void ShouldSupportStructsFromTheStaticApi()
         [Fact]
         public void ShouldSupportStructMergePlansFromTheStaticApi()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicTwoFieldsStruct<int, int>>()
                 .OnTo<PublicTwoFieldsStruct<string, string>>();
 
@@ -85,7 +85,7 @@ public void ShouldSupportStructsFromTheInstanceApi()
         {
             using (var mapper = Mapper.CreateNew())
             {
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicPropertyStruct<string>>()
                     .ToANew<PublicCtorStruct<string>>();
 
@@ -98,7 +98,7 @@ public void ShouldSupportStructsFromTheInstanceApi()
         [Fact]
         public void ShouldIncludeAComplexTypeMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PersonViewModel>()
                 .ToANew<Person>();
 
@@ -109,7 +109,7 @@ public void ShouldIncludeAComplexTypeMemberMapping()
         [Fact]
         public void ShouldIncludeASimpleTypeEnumerableMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<int[]>>()
                 .ToANew<PublicField<IEnumerable<int>>>();
 
@@ -123,7 +123,7 @@ public void ShouldIncludeASimpleTypeEnumerableMemberMapping()
         [Fact]
         public void ShouldIncludeASimpleTypeMemberConversion()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<Guid>>()
                 .ToANew<PublicField<string>>();
 
@@ -142,7 +142,7 @@ public void ShouldIncludeAConfiguredExpression()
                     .Map((p, pvm) => p.Title + " " + p.Name)
                     .To(pvm => pvm.Name);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<Person>()
                     .Over<PersonViewModel>();
 
@@ -153,7 +153,7 @@ public void ShouldIncludeAConfiguredExpression()
         [Fact]
         public void ShouldIncludeARootComplexTypeEnumerableMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<IEnumerable<Person>>()
                 .OnTo<IEnumerable<PersonViewModel>>();
 
@@ -164,7 +164,7 @@ public void ShouldIncludeARootComplexTypeEnumerableMapping()
         [Fact]
         public void ShouldIncludeAComplexTypeEnumerableMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<IList<PersonViewModel>>()
                 .Over<IEnumerable<Person>>();
 
@@ -180,7 +180,7 @@ public void ShouldIncludeAComplexTypeEnumerableMemberMapping()
         [Fact]
         public void ShouldIncludeAMemberWithNoDataSource()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PersonViewModel>()
                 .OnTo<Person>();
 
@@ -197,7 +197,7 @@ public void ShouldIncludeAnIgnoredMember()
                     .To<PersonViewModel>()
                     .Ignore(pvm => pvm.AddressLine1);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<Person>()
                     .ToANew<PersonViewModel>();
 
@@ -217,7 +217,7 @@ public void ShouldNotIncludeASourceMemberWithTheSameConditionAsAConfiguredMember
                     .Map((pf, pp) => pf.Value.Value)
                     .To(pp => pp.Value);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicField<PublicField<string>>>()
                     .ToANew<PublicProperty<string>>();
 
@@ -229,7 +229,7 @@ public void ShouldNotIncludeASourceMemberWithTheSameConditionAsAConfiguredMember
         [Fact]
         public void ShouldShowInlineMappers()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicField<PublicField<PublicField<int>>>>()
                 .ToANew<PublicField<PublicSealed<PublicSealed<long>>>>();
 
@@ -241,7 +241,7 @@ public void ShouldShowInlineMappers()
         [Fact]
         public void ShouldShowMapChildCalls()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<object>>()
                 .ToANew<PublicSetMethod<Customer>>();
 
@@ -254,7 +254,7 @@ public void ShouldShowMapChildCalls()
         [Fact]
         public void ShouldShowNestedMapChildCalls()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<PublicField<object>>>()
                 .ToANew<PublicSetMethod<PublicProperty<Order>>>();
 
@@ -277,7 +277,7 @@ public void ShouldShowMapChildObjectCalls()
                     .To(ptf => ptf.Value1);
 
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicProperty<string>>()
                     .ToANew<PublicTwoFields<string, object>>();
 
@@ -290,7 +290,7 @@ public void ShouldShowMapChildObjectCalls()
         [Fact]
         public void ShouldShowMapElementCalls()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<object[]>>()
                 .ToANew<PublicSetMethod<ICollection<Product>>>();
 
@@ -303,7 +303,7 @@ public void ShouldShowMapElementCalls()
         [Fact]
         public void ShouldShowDictionaryElementMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<List<PublicField<Dictionary<int, string>>>>()
                 .ToANew<List<PublicField<Dictionary<int, string>>>>();
 
@@ -317,7 +317,7 @@ public void ShouldShowObjectTracking()
             {
                 mapper.WhenMapping.TrackMappedObjects();
 
-                var plan = mapper.GetPlanFor<Parent>().ToANew<Parent>();
+                string plan = mapper.GetPlanFor<Parent>().ToANew<Parent>();
 
                 plan.ShouldContain("pToPData.TryGet(sourceChild.EldestParent, out parent)");
                 plan.ShouldContain("pToPData.Register(sourceChild.EldestParent, parent)");
@@ -327,7 +327,7 @@ public void ShouldShowObjectTracking()
         [Fact]
         public void ShouldNotDuplicateChildMappingPlans()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicTwoFields<object, object>>()
                 .ToANew<PublicTwoParamCtor<Product, Product>>();
 
@@ -339,7 +339,7 @@ public void ShouldNotDuplicateChildMappingPlans()
         [Fact]
         public void ShouldNotRangeCheckNullableToNonNullableValues()
         {
-            var plan = Mapper.GetPlanFor<PublicField<int?>>().ToANew<PublicField<int>>();
+            string plan = Mapper.GetPlanFor<PublicField<int?>>().ToANew<PublicField<int>>();
 
             plan.ShouldNotContain("int.MinValue");
         }
@@ -347,7 +347,7 @@ public void ShouldNotRangeCheckNullableToNonNullableValues()
         [Fact]
         public void ShouldShowEnumMismatches()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<OrderUs>()
                 .ToANew<OrderUk>();
 
@@ -369,7 +369,7 @@ public void ShouldShowMultipleEnumSourceMembers()
                     .If((s, o) => s.Value1 == PaymentTypeUk.Cheque)
                     .Map((s, o) => s.Value2).To(o => o.PaymentType);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicTwoFields<PaymentTypeUk, PaymentTypeUs>>()
                     .ToANew<OrderUs>();
 
@@ -383,7 +383,7 @@ public void ShouldShowMultipleEnumSourceMembers()
         [Fact]
         public void ShouldShowNestedEnumMismatches()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicField<OrderUs>>()
                 .ToANew<PublicProperty<OrderUk>>();
 
@@ -394,7 +394,7 @@ public void ShouldShowNestedEnumMismatches()
         [Fact]
         public void ShouldNotAssignATargetMemberToItself()
         {
-            var plan = Mapper.GetPlanFor<PublicField<string>>().OnTo<PublicField<string>>();
+            string plan = Mapper.GetPlanFor<PublicField<string>>().OnTo<PublicField<string>>();
 
             plan.ShouldNotContain("publicField_String.Value = publicField_String.Value");
         }
@@ -408,7 +408,7 @@ public void ShouldIncludeMemberFilterExpressions()
                     .To<Address>()
                     .IgnoreTargetMembersWhere(member => member.IsPropertyMatching(p => p.Name == "Line2"));
 
-                var plan = mapper.GetPlanFor<Address>().ToANew<Address>();
+                string plan = mapper.GetPlanFor<Address>().ToANew<Address>();
 
                 plan.ShouldContain("member.IsPropertyMatching(p => p.Name == \"Line2\")");
             }
@@ -419,7 +419,7 @@ public void ShouldIncludeUnmappableStructComplexTypeMemberDetails()
         {
             using (var mapper = Mapper.CreateNew())
             {
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicTwoFields<Person, string>>()
                     .ToANew<PublicTwoFieldsStruct<Person, int>>();
 
@@ -439,7 +439,7 @@ public void ShouldIncludeUnmappableReadOnlyArrayMemberDetails()
                     .Map(ctx => ctx.Source.Value)
                     .ToCtor<int[]>();
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicField<string[]>>()
                     .ToANew<PublicReadOnlyField<int[]>>();
 
@@ -458,7 +458,7 @@ public void ShouldIncludeUnmappableReadOnlyReadOnlyCollectionMemberDetails()
                     .Map(ctx => ctx.Source.Value)
                     .ToCtor("readOnlyValue");
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicField<string[]>>()
                     .ToANew<PublicReadOnlyField<ReadOnlyCollection<int>>>();
 
@@ -477,7 +477,7 @@ public void ShouldIncludeUnmappableReadOnlyIntMemberDetails()
                     .Map(ctx => ctx.Source.Value)
                     .ToCtor("readOnlyValue");
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicField<string>>()
                     .ToANew<PublicReadOnlyField<int>>();
 
diff --git a/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
index 9fcfaa19d..60bd23413 100644
--- a/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
+++ b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
@@ -1,33 +1,47 @@
 namespace AgileObjects.AgileMapper.Api
 {
+    using Plans;
+
     /// <summary>
     /// Provides options to create and compile mapping functions for a particular type of mapping from the 
     /// source type being configured to a specified target type.
     /// </summary>
-    public interface IPlanTargetTypeAndRuleSetSelector
+    public interface IPlanTargetTypeAndRuleSetSelector<TSource>
     {
         /// <summary>
         /// Create and compile mapping functions for a create new mapping from the source type being 
         /// configured to the type specified by the type argument.
         /// </summary>
         /// <typeparam name="TResult">The type of object for which to create the mapping plan.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        string ToANew<TResult>();
+        /// <returns>
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> object detailing the function to be executed 
+        /// during a mapping. To see a string representation of the function assign the result to a string
+        /// variable, or call .ToString().
+        /// </returns>
+        MappingPlan<TSource, TResult> ToANew<TResult>();
 
         /// <summary>
         /// Create and compile mapping functions for an OnTo (merge) mapping from the source type being 
         /// configured to the type specified by the type argument.
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        string OnTo<TTarget>();
+        /// <returns>
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> object detailing the function to be executed 
+        /// during a mapping. To see a string representation of the function assign the result to a string
+        /// variable, or call .ToString().
+        /// </returns>
+        MappingPlan<TSource, TTarget> OnTo<TTarget>();
 
         /// <summary>
         /// Create and compile mapping functions for an Over (overwrite) mapping from the source type being 
         /// configured to the type specified by the type argument.
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        string Over<TTarget>();
+        /// <returns>
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> object detailing the function to be executed 
+        /// during a mapping. To see a string representation of the function assign the result to a string
+        /// variable, or call .ToString().
+        /// </returns>
+        MappingPlan<TSource, TTarget> Over<TTarget>();
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Api/IPlanTargetTypeSelector.cs b/AgileMapper/Api/IPlanTargetTypeSelector.cs
index 55f6611f9..3514fc653 100644
--- a/AgileMapper/Api/IPlanTargetTypeSelector.cs
+++ b/AgileMapper/Api/IPlanTargetTypeSelector.cs
@@ -1,17 +1,23 @@
 namespace AgileObjects.AgileMapper.Api
 {
+    using Plans;
+
     /// <summary>
     /// Provides the option to create and compile mapping functions for mappings from the source type 
     /// being configured to a specified target type, for all mapping types (create new, merge, overwrite).
     /// </summary>
-    public interface IPlanTargetTypeSelector
+    public interface IPlanTargetTypeSelector<TSource>
     {
         /// <summary>
         /// Create and compile mapping functions from the source type being configured to the type specified 
         /// by the type argument, for all mapping types (create new, merge, overwrite).
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
-        /// <returns>A set of string mapping plans showing the functions to be executed during a mapping.</returns>
-        string To<TTarget>();
+        /// <returns>
+        /// A <see cref="MappingPlanSet{TSource,TTarget}"/> object detailing the functions to be executed 
+        /// during a mapping. To see a string representation of the function assign the result to a string
+        /// variable, or call .ToString().
+        /// </returns>
+        MappingPlanSet<TSource, TTarget> To<TTarget>();
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Api/PlanTargetTypeSelector.cs b/AgileMapper/Api/PlanTargetTypeSelector.cs
index f4e7dc99a..10b6390a9 100644
--- a/AgileMapper/Api/PlanTargetTypeSelector.cs
+++ b/AgileMapper/Api/PlanTargetTypeSelector.cs
@@ -3,7 +3,7 @@
     using System.Linq;
     using Plans;
 
-    internal class PlanTargetTypeSelector<TSource> : IPlanTargetTypeSelector, IPlanTargetTypeAndRuleSetSelector
+    internal class PlanTargetTypeSelector<TSource> : IPlanTargetTypeSelector<TSource>, IPlanTargetTypeAndRuleSetSelector<TSource>
     {
         private readonly MapperContext _mapperContext;
 
@@ -12,7 +12,7 @@ internal PlanTargetTypeSelector(MapperContext mapperContext)
             _mapperContext = mapperContext;
         }
 
-        public string To<TTarget>()
+        public MappingPlanSet<TSource, TTarget> To<TTarget>()
         {
             return new MappingPlanSet<TSource, TTarget>(
                 _mapperContext
@@ -22,13 +22,13 @@ public string To<TTarget>()
                     .ToArray());
         }
 
-        public string ToANew<TResult>()
+        public MappingPlan<TSource, TResult> ToANew<TResult>()
             => GetMappingPlan<TResult>(_mapperContext.RuleSets.CreateNew);
 
-        public string OnTo<TTarget>()
+        public MappingPlan<TSource, TTarget> OnTo<TTarget>()
             => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Merge);
 
-        public string Over<TTarget>()
+        public MappingPlan<TSource, TTarget> Over<TTarget>()
             => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Overwrite);
 
         private MappingPlan<TSource, TTarget> GetMappingPlan<TTarget>(MappingRuleSet ruleSet)
diff --git a/AgileMapper/IMapper.cs b/AgileMapper/IMapper.cs
index bb6218c49..3419c94b5 100644
--- a/AgileMapper/IMapper.cs
+++ b/AgileMapper/IMapper.cs
@@ -24,7 +24,7 @@ public interface IMapper : IDisposable
         /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
         /// should be cached.
         /// </returns>
-        IPlanTargetTypeSelector GetPlansFor<TSource>();
+        IPlanTargetTypeSelector<TSource> GetPlansFor<TSource>();
 
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
@@ -38,7 +38,7 @@ public interface IMapper : IDisposable
         /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
         /// should be cached.
         /// </returns>
-        IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>(TSource exampleInstance);
+        IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance);
 
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
@@ -49,7 +49,7 @@ public interface IMapper : IDisposable
         /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
         /// should be cached.
         /// </returns>
-        IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>();
+        IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>();
 
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
diff --git a/AgileMapper/Mapper.cs b/AgileMapper/Mapper.cs
index 680796358..5ea031ff0 100644
--- a/AgileMapper/Mapper.cs
+++ b/AgileMapper/Mapper.cs
@@ -28,11 +28,11 @@ private Mapper(MapperContext mapperContext)
 
         #endregion
 
-        IPlanTargetTypeSelector IMapper.GetPlansFor<TSource>() => GetPlan<TSource>();
+        IPlanTargetTypeSelector<TSource> IMapper.GetPlansFor<TSource>() => GetPlan<TSource>();
 
-        IPlanTargetTypeAndRuleSetSelector IMapper.GetPlanFor<TSource>(TSource exampleInstance) => GetPlan<TSource>();
+        IPlanTargetTypeAndRuleSetSelector<TSource> IMapper.GetPlanFor<TSource>(TSource exampleInstance) => GetPlan<TSource>();
 
-        IPlanTargetTypeAndRuleSetSelector IMapper.GetPlanFor<TSource>() => GetPlan<TSource>();
+        IPlanTargetTypeAndRuleSetSelector<TSource> IMapper.GetPlanFor<TSource>() => GetPlan<TSource>();
 
         private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
             => new PlanTargetTypeSelector<TSource>(_mapperContext);
@@ -52,7 +52,7 @@ private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
         /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
         /// should be cached.
         /// </returns>
-        public static IPlanTargetTypeSelector GetPlansFor<TSource>() => _default.GetPlansFor<TSource>();
+        public static IPlanTargetTypeSelector<TSource> GetPlansFor<TSource>() => _default.GetPlansFor<TSource>();
 
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
@@ -66,7 +66,7 @@ private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
         /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
         /// should be cached.
         /// </returns>
-        public static IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
+        public static IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
 
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
@@ -77,7 +77,7 @@ private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
         /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
         /// should be cached.
         /// </returns>
-        public static IPlanTargetTypeAndRuleSetSelector GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
+        public static IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
 
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
diff --git a/AgileMapper/Plans/MappingPlan.cs b/AgileMapper/Plans/MappingPlan.cs
index 958ec8341..afa6d86c4 100644
--- a/AgileMapper/Plans/MappingPlan.cs
+++ b/AgileMapper/Plans/MappingPlan.cs
@@ -7,11 +7,23 @@
     using ObjectPopulation;
     using NetStandardPolyfills;
 
-    internal class MappingPlan<TSource, TTarget>
+    /// <summary>
+    /// Contains details of the mapping plan for a mapping between a particular source and target type,
+    /// for a particular mapping type (create new, merge, overwrite).
+    /// </summary>
+    /// <typeparam name="TSource">
+    /// The type of source object from which the mapping described by the
+    /// <see cref="MappingPlan{TSource,TTarget}"/> is performed.
+    /// </typeparam>
+    /// <typeparam name="TTarget">
+    /// The type of target object to which the mapping described by the
+    /// <see cref="MappingPlan{TSource,TTarget}"/> is performed.
+    /// </typeparam>
+    public class MappingPlan<TSource, TTarget>
     {
         private readonly List<MappingPlanData> _generatedPlanData;
 
-        public MappingPlan(IMappingContext mappingContext)
+        internal MappingPlan(IMappingContext mappingContext)
         {
             _generatedPlanData = new List<MappingPlanData>();
 
@@ -53,6 +65,11 @@ private void Expand(MappingPlanData planData)
 
         private static bool IsObjectMemberMapping(MethodCallExpression mapCall) => mapCall.Arguments.Count == 4;
 
+        /// <summary>
+        /// Converts the given <paramref name="mappingPlan"/> to its string representation.
+        /// </summary>
+        /// <param name="mappingPlan">The <see cref="MappingPlan{TSource,TTarget}"/> to convert.</param>
+        /// <returns>The string representation of the given <paramref name="mappingPlan"/>.</returns>
         public static implicit operator string(MappingPlan<TSource, TTarget> mappingPlan)
         {
             return string.Join(
@@ -96,5 +113,11 @@ private static bool IsMapCall(MethodCallExpression methodCall)
                        (methodCall.Object.Type.GetGenericTypeDefinition() == typeof(IObjectMappingData<,>));
             }
         }
+
+        /// <summary>
+        /// Returns the string representation of the <see cref="MappingPlan{TSource,TTarget}"/>.
+        /// </summary>
+        /// <returns>The string representation of the <see cref="MappingPlan{TSource,TTarget}"/>.</returns>
+        public override string ToString() => this;
     }
 }
diff --git a/AgileMapper/Plans/MappingPlanSet.cs b/AgileMapper/Plans/MappingPlanSet.cs
index 9292eec3f..a30ac4eb8 100644
--- a/AgileMapper/Plans/MappingPlanSet.cs
+++ b/AgileMapper/Plans/MappingPlanSet.cs
@@ -4,20 +4,46 @@
     using System.Collections.Generic;
     using System.Linq;
 
-    internal class MappingPlanSet<TSource, TTarget>
+    /// <summary>
+    /// Contains details of the mapping plan for a mapping between a particular source and target type,
+    /// for all mapping types (create new, merge, overwrite).
+    /// </summary>
+    /// <typeparam name="TSource">
+    /// The type of source object from which the mapping described by the
+    /// <see cref="MappingPlanSet{TSource,TTarget}"/> is performed.
+    /// </typeparam>
+    /// <typeparam name="TTarget">
+    /// The type of target object to which the mapping described by the
+    /// <see cref="MappingPlanSet{TSource,TTarget}"/> is performed.
+    /// </typeparam>
+    public class MappingPlanSet<TSource, TTarget>
     {
         private readonly IEnumerable<MappingPlan<TSource, TTarget>> _mappingPlans;
 
-        public MappingPlanSet(IEnumerable<MappingPlan<TSource, TTarget>> mappingPlans)
+        internal MappingPlanSet(IEnumerable<MappingPlan<TSource, TTarget>> mappingPlans)
         {
             _mappingPlans = mappingPlans;
         }
 
+        /// <summary>
+        /// Converts the given <paramref name="mappingPlans">MappingPlanSet</paramref> to its string 
+        /// representation.
+        /// </summary>
+        /// <param name="mappingPlans">The <see cref="MappingPlan{TSource,TTarget}"/> to convert.</param>
+        /// <returns>
+        /// The string representation of the <paramref name="mappingPlans">MappingPlanSet</paramref>.
+        /// </returns>
         public static implicit operator string(MappingPlanSet<TSource, TTarget> mappingPlans)
         {
             return string.Join(
                 Environment.NewLine + Environment.NewLine,
                 mappingPlans._mappingPlans.Select(plan => (string)plan));
         }
+
+        /// <summary>
+        /// Returns the string representation of the <see cref="MappingPlanSet{TSource,TTarget}"/>.
+        /// </summary>
+        /// <returns>The string representation of the <see cref="MappingPlanSet{TSource,TTarget}"/>.</returns>
+        public override string ToString() => this;
     }
 }
\ No newline at end of file

From 8ed0f1e5ebfea9ccb6cb6e292c80dff559b67c2b Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Fri, 20 Oct 2017 17:19:41 +0100
Subject: [PATCH 7/8] Adding Mapper.GetPlansInCache() to expose all
 currently-cached mapping plans

---
 .../WhenViewingMappingPlans.cs                | 17 +++++++
 .../Api/IPlanTargetTypeAndRuleSetSelector.cs  | 12 ++---
 AgileMapper/Api/IPlanTargetTypeSelector.cs    | 10 ++--
 AgileMapper/Api/PlanTargetTypeSelector.cs     |  6 +--
 AgileMapper/Caching/ArrayCache.cs             | 28 -----------
 AgileMapper/Caching/ICache.cs                 |  2 -
 AgileMapper/IMapper.cs                        | 29 +++++++-----
 AgileMapper/Mapper.cs                         | 35 ++++++++------
 AgileMapper/ObjectPopulation/IObjectMapper.cs |  3 ++
 AgileMapper/ObjectPopulation/ObjectMapper.cs  |  3 ++
 .../ObjectPopulation/ObjectMapperFactory.cs   |  2 +
 AgileMapper/Plans/CachedMapperMappingPlan.cs  | 46 +++++++++++++++++++
 .../Plans/EnumMappingMismatchFinder.cs        | 12 ++---
 AgileMapper/Plans/IMappingPlan.cs             |  6 +++
 AgileMapper/Plans/MappingPlan.cs              |  2 +-
 AgileMapper/Plans/MappingPlanData.cs          | 27 +----------
 AgileMapper/Plans/MappingPlanFunction.cs      | 35 ++++++++++++++
 AgileMapper/Plans/MappingPlanSet.cs           | 35 +++++++-------
 18 files changed, 191 insertions(+), 119 deletions(-)
 create mode 100644 AgileMapper/Plans/CachedMapperMappingPlan.cs
 create mode 100644 AgileMapper/Plans/IMappingPlan.cs
 create mode 100644 AgileMapper/Plans/MappingPlanFunction.cs

diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index e02311455..dd43315be 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -484,5 +484,22 @@ public void ShouldIncludeUnmappableReadOnlyIntMemberDetails()
                 plan.ShouldContain("readonly int");
             }
         }
+
+        [Fact]
+        public void ShouldShowAllCachedMappingPlans()
+        {
+            Mapper.GetPlanFor<PublicField<string>>().ToANew<PublicProperty<int>>();
+            Mapper.GetPlanFor<Customer>().ToANew<CustomerViewModel>();
+            Mapper.GetPlansFor<MegaProduct>().To<ProductDtoMega>();
+
+            var plan = Mapper.GetPlansInCache();
+
+            plan.ShouldContain("PublicField<string> -> PublicProperty<int>");
+            plan.ShouldContain("Customer -> CustomerViewModel");
+            plan.ShouldContain("MegaProduct -> ProductDtoMega");
+            plan.ShouldContain("Rule set: CreateNew");
+            plan.ShouldContain("Rule set: Merge");
+            plan.ShouldContain("Rule set: Overwrite");
+        }
     }
 }
diff --git a/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
index 60bd23413..bf3aabbfc 100644
--- a/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
+++ b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
@@ -26,9 +26,9 @@ public interface IPlanTargetTypeAndRuleSetSelector<TSource>
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
         /// <returns>
-        /// A <see cref="MappingPlan{TSource,TTarget}"/> object detailing the function to be executed 
-        /// during a mapping. To see a string representation of the function assign the result to a string
-        /// variable, or call .ToString().
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> detailing the function to be executed during a mapping. 
+        /// To see a string representation of the function, assign the result to an explitly-typed string variable, 
+        /// or call .ToString().
         /// </returns>
         MappingPlan<TSource, TTarget> OnTo<TTarget>();
 
@@ -38,9 +38,9 @@ public interface IPlanTargetTypeAndRuleSetSelector<TSource>
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
         /// <returns>
-        /// A <see cref="MappingPlan{TSource,TTarget}"/> object detailing the function to be executed 
-        /// during a mapping. To see a string representation of the function assign the result to a string
-        /// variable, or call .ToString().
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> detailing the function to be executed during a mapping. 
+        /// To see a string representation of the function, assign the result to an explitly-typed string variable, 
+        /// or call .ToString().
         /// </returns>
         MappingPlan<TSource, TTarget> Over<TTarget>();
     }
diff --git a/AgileMapper/Api/IPlanTargetTypeSelector.cs b/AgileMapper/Api/IPlanTargetTypeSelector.cs
index 3514fc653..86fc18d45 100644
--- a/AgileMapper/Api/IPlanTargetTypeSelector.cs
+++ b/AgileMapper/Api/IPlanTargetTypeSelector.cs
@@ -6,7 +6,7 @@
     /// Provides the option to create and compile mapping functions for mappings from the source type 
     /// being configured to a specified target type, for all mapping types (create new, merge, overwrite).
     /// </summary>
-    public interface IPlanTargetTypeSelector<TSource>
+    public interface IPlanTargetTypeSelector
     {
         /// <summary>
         /// Create and compile mapping functions from the source type being configured to the type specified 
@@ -14,10 +14,10 @@ public interface IPlanTargetTypeSelector<TSource>
         /// </summary>
         /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
         /// <returns>
-        /// A <see cref="MappingPlanSet{TSource,TTarget}"/> object detailing the functions to be executed 
-        /// during a mapping. To see a string representation of the function assign the result to a string
-        /// variable, or call .ToString().
+        /// A <see cref="MappingPlanSet"/> detailing the functions to be executed during a mapping. To see 
+        /// string representations of the functions, assign the result to an explicitly-typed string variable, 
+        /// or call .ToString().
         /// </returns>
-        MappingPlanSet<TSource, TTarget> To<TTarget>();
+        MappingPlanSet To<TTarget>();
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Api/PlanTargetTypeSelector.cs b/AgileMapper/Api/PlanTargetTypeSelector.cs
index 10b6390a9..0e8c972bf 100644
--- a/AgileMapper/Api/PlanTargetTypeSelector.cs
+++ b/AgileMapper/Api/PlanTargetTypeSelector.cs
@@ -3,7 +3,7 @@
     using System.Linq;
     using Plans;
 
-    internal class PlanTargetTypeSelector<TSource> : IPlanTargetTypeSelector<TSource>, IPlanTargetTypeAndRuleSetSelector<TSource>
+    internal class PlanTargetTypeSelector<TSource> : IPlanTargetTypeSelector, IPlanTargetTypeAndRuleSetSelector<TSource>
     {
         private readonly MapperContext _mapperContext;
 
@@ -12,9 +12,9 @@ internal PlanTargetTypeSelector(MapperContext mapperContext)
             _mapperContext = mapperContext;
         }
 
-        public MappingPlanSet<TSource, TTarget> To<TTarget>()
+        public MappingPlanSet To<TTarget>()
         {
-            return new MappingPlanSet<TSource, TTarget>(
+            return new MappingPlanSet(
                 _mapperContext
                     .RuleSets
                     .All
diff --git a/AgileMapper/Caching/ArrayCache.cs b/AgileMapper/Caching/ArrayCache.cs
index cc0936d91..d93bd27c1 100644
--- a/AgileMapper/Caching/ArrayCache.cs
+++ b/AgileMapper/Caching/ArrayCache.cs
@@ -108,21 +108,6 @@ private T[] ResizeToCapacity<T>(T[] existingArray)
             return biggerArray;
         }
 
-        //public void CloneTo(ICache<TKey, TValue> otherCache)
-        //{
-        //    for (var i = 0; i < _length; i++)
-        //    {
-        //        var value = _values[i];
-
-        //        if (value is ICloneable cloneable)
-        //        {
-        //            value = (TValue)cloneable.Clone();
-        //        }
-
-        //        otherCache.GetOrAdd(_keys[i], m => value);
-        //    }
-        //}
-
         public void Empty()
         {
             for (var i = 0; i < _length; i++)
@@ -133,18 +118,5 @@ public void Empty()
 
             _length = 0;
         }
-
-        //object ICloneable.Clone()
-        //{
-        //    var cache = new ArrayCache<TKey, TValue>(Math.Max(_length, DefaultCapacity));
-
-        //    for (var i = 0; i < _length; i++)
-        //    {
-        //        cache._keys[i] = _keys[i];
-        //        cache._values[i] = _values[i];
-        //    }
-
-        //    return cache;
-        //}
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Caching/ICache.cs b/AgileMapper/Caching/ICache.cs
index c947def62..f116d7b9d 100644
--- a/AgileMapper/Caching/ICache.cs
+++ b/AgileMapper/Caching/ICache.cs
@@ -13,7 +13,5 @@ internal interface ICache<TKey, TValue> : ICache
         IEnumerable<TValue> Values { get; }
 
         TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory);
-
-        //void CloneTo(ICache<TKey, TValue> otherCache);
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/IMapper.cs b/AgileMapper/IMapper.cs
index 3419c94b5..6c089c68a 100644
--- a/AgileMapper/IMapper.cs
+++ b/AgileMapper/IMapper.cs
@@ -3,6 +3,7 @@
     using System;
     using Api;
     using Api.Configuration;
+    using Plans;
 
     /// <summary>
     /// Provides mapping and mapping configuration services.
@@ -15,17 +16,6 @@ public interface IMapper : IDisposable
         /// <returns>A cloned copy of this mapper.</returns>
         IMapper CloneSelf();
 
-        /// <summary>
-        /// Create and compile mapping functions for the source type specified by the type argument, for all
-        /// mapping types (create new, merge, overwrite).
-        /// </summary>
-        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
-        /// <returns>
-        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
-        /// should be cached.
-        /// </returns>
-        IPlanTargetTypeSelector<TSource> GetPlansFor<TSource>();
-
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
         /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
@@ -51,6 +41,23 @@ public interface IMapper : IDisposable
         /// </returns>
         IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>();
 
+        /// <summary>
+        /// Create and compile mapping functions for the source type specified by the type argument, for all
+        /// mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        IPlanTargetTypeSelector GetPlansFor<TSource>();
+
+        /// <summary>
+        /// Returns mapping plans for all mapping functions currently cached by the <see cref="IMapper"/>.
+        /// </summary>
+        /// <returns>A string containing the currently-cached functions to be executed during mappings.</returns>
+        string GetPlansInCache();
+
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
         /// and target types.
diff --git a/AgileMapper/Mapper.cs b/AgileMapper/Mapper.cs
index 5ea031ff0..dcf710ac6 100644
--- a/AgileMapper/Mapper.cs
+++ b/AgileMapper/Mapper.cs
@@ -2,6 +2,7 @@
 {
     using Api;
     using Api.Configuration;
+    using Plans;
 
     /// <summary>
     /// Provides a configurable mapping service. Create new instances with Mapper.CreateNew or use the default
@@ -28,12 +29,14 @@ private Mapper(MapperContext mapperContext)
 
         #endregion
 
-        IPlanTargetTypeSelector<TSource> IMapper.GetPlansFor<TSource>() => GetPlan<TSource>();
-
         IPlanTargetTypeAndRuleSetSelector<TSource> IMapper.GetPlanFor<TSource>(TSource exampleInstance) => GetPlan<TSource>();
 
         IPlanTargetTypeAndRuleSetSelector<TSource> IMapper.GetPlanFor<TSource>() => GetPlan<TSource>();
 
+        IPlanTargetTypeSelector IMapper.GetPlansFor<TSource>() => GetPlan<TSource>();
+
+        string IMapper.GetPlansInCache() => MappingPlanSet.For(_mapperContext);
+
         private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
             => new PlanTargetTypeSelector<TSource>(_mapperContext);
 
@@ -43,17 +46,6 @@ private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
 
         #region Static Access Methods
 
-        /// <summary>
-        /// Create and compile mapping functions for the source type specified by the type argument, for all
-        /// mapping types (create new, merge, overwrite).
-        /// </summary>
-        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
-        /// <returns>
-        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
-        /// should be cached.
-        /// </returns>
-        public static IPlanTargetTypeSelector<TSource> GetPlansFor<TSource>() => _default.GetPlansFor<TSource>();
-
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
         /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
@@ -79,6 +71,23 @@ private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
         /// </returns>
         public static IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
 
+        /// <summary>
+        /// Create and compile mapping functions for the source type specified by the type argument, for all
+        /// mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        public static IPlanTargetTypeSelector GetPlansFor<TSource>() => _default.GetPlansFor<TSource>();
+
+        /// <summary>
+        /// Returns mapping plans for all mapping functions currently cached by the default <see cref="IMapper"/>.
+        /// </summary>
+        /// <returns>A string containing the currently-cached functions to be executed during mappings.</returns>
+        public static string GetPlansInCache() => _default.GetPlansInCache();
+
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
         /// and target types.
diff --git a/AgileMapper/ObjectPopulation/IObjectMapper.cs b/AgileMapper/ObjectPopulation/IObjectMapper.cs
index 3a44f8ccb..14c9bcf7e 100644
--- a/AgileMapper/ObjectPopulation/IObjectMapper.cs
+++ b/AgileMapper/ObjectPopulation/IObjectMapper.cs
@@ -1,5 +1,6 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation
 {
+    using System.Collections.Generic;
     using System.Linq.Expressions;
 
     internal interface IObjectMapper : IObjectMapperFunc
@@ -9,5 +10,7 @@ internal interface IObjectMapper : IObjectMapperFunc
         LambdaExpression MappingLambda { get; }
 
         ObjectMapperData MapperData { get; }
+
+        IEnumerable<IObjectMapper> SubMappers { get; }
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/ObjectPopulation/ObjectMapper.cs b/AgileMapper/ObjectPopulation/ObjectMapper.cs
index 5362dd3b2..f653ff460 100644
--- a/AgileMapper/ObjectPopulation/ObjectMapper.cs
+++ b/AgileMapper/ObjectPopulation/ObjectMapper.cs
@@ -1,6 +1,7 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation
 {
     using System;
+    using System.Collections.Generic;
     using System.Linq.Expressions;
 #if NET_STANDARD
     using System.Reflection;
@@ -84,6 +85,8 @@ private ICache<ObjectMapperKeyBase, IObjectMapperFunc> CreateRecursionMapperFunc
 
         public ObjectMapperData MapperData { get; }
 
+        public IEnumerable<IObjectMapper> SubMappers => _subMappersByKey?.Values ?? Enumerable<IObjectMapper>.Empty;
+
         public object Map(IObjectMappingData mappingData) => Map((ObjectMappingData<TSource, TTarget>)mappingData);
 
         public TTarget Map(ObjectMappingData<TSource, TTarget> mappingData) => _mapperFunc.Invoke(mappingData);
diff --git a/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs b/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs
index 75783cecb..9f1650c7c 100644
--- a/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs
+++ b/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs
@@ -25,6 +25,8 @@ public ObjectMapperFactory(MapperContext mapperContext)
             _rootMappersCache = mapperContext.Cache.CreateScoped<ObjectMapperKeyBase, IObjectMapper>();
         }
 
+        public IEnumerable<IObjectMapper> RootMappers => _rootMappersCache.Values;
+
         public ObjectMapper<TSource, TTarget> GetOrCreateRoot<TSource, TTarget>(ObjectMappingData<TSource, TTarget> mappingData)
         {
             mappingData.MapperKey.MappingData = mappingData;
diff --git a/AgileMapper/Plans/CachedMapperMappingPlan.cs b/AgileMapper/Plans/CachedMapperMappingPlan.cs
new file mode 100644
index 000000000..2b4976088
--- /dev/null
+++ b/AgileMapper/Plans/CachedMapperMappingPlan.cs
@@ -0,0 +1,46 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using ObjectPopulation;
+
+    internal class CachedMapperMappingPlan : IMappingPlan
+    {
+        private readonly List<IObjectMapper> _cachedMappers;
+
+        public CachedMapperMappingPlan(IObjectMapper mapper)
+        {
+            _cachedMappers = new List<IObjectMapper>();
+
+            Expand(mapper);
+        }
+
+        private void Expand(IObjectMapper mapper)
+        {
+            _cachedMappers.Add(mapper);
+
+            foreach (var subMapper in mapper.SubMappers)
+            {
+                Expand(subMapper);
+            }
+        }
+
+        /// <summary>
+        /// Converts the given <paramref name="mappingPlan"/> to its string representation.
+        /// </summary>
+        /// <param name="mappingPlan">The <see cref="CachedMapperMappingPlan"/> to convert.</param>
+        /// <returns>The string representation of the given <paramref name="mappingPlan"/>.</returns>
+        public static implicit operator string(CachedMapperMappingPlan mappingPlan)
+        {
+            return string.Join(
+                Environment.NewLine + Environment.NewLine,
+                mappingPlan._cachedMappers.Select(GetDescription));
+        }
+
+        private static string GetDescription(IObjectMapper mapper)
+            => MappingPlanFunction.For(mapper.MappingLambda, mapper.MapperData);
+
+        public override string ToString() => this;
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Plans/EnumMappingMismatchFinder.cs b/AgileMapper/Plans/EnumMappingMismatchFinder.cs
index cb10acb50..b7640abbb 100644
--- a/AgileMapper/Plans/EnumMappingMismatchFinder.cs
+++ b/AgileMapper/Plans/EnumMappingMismatchFinder.cs
@@ -25,18 +25,16 @@ private EnumMappingMismatchFinder(
             _assignmentReplacements = new Dictionary<Expression, Expression>();
         }
 
-        public static Expression Process(Expression lambda, IObjectMappingData mappingData)
+        public static Expression Process(Expression lambda, ObjectMapperData mapperData)
         {
-            var targetMemberDatas = GetAllTargetMemberDatas(mappingData);
+            var targetMemberDatas = GetAllTargetMemberDatas(mapperData);
 
             if (targetMemberDatas.None())
             {
                 return lambda;
             }
 
-            var finder = new EnumMappingMismatchFinder(
-                mappingData.MapperData,
-                targetMemberDatas);
+            var finder = new EnumMappingMismatchFinder(mapperData, targetMemberDatas);
 
             finder.Visit(lambda);
 
@@ -45,8 +43,8 @@ public static Expression Process(Expression lambda, IObjectMappingData mappingDa
             return updatedLambda;
         }
 
-        private static TargetMemberData[] GetAllTargetMemberDatas(IObjectMappingData mappingData)
-            => EnumerateTargetMemberDatas(mappingData.MapperData).ToArray();
+        private static TargetMemberData[] GetAllTargetMemberDatas(ObjectMapperData mapperData)
+            => EnumerateTargetMemberDatas(mapperData).ToArray();
 
         private static IEnumerable<TargetMemberData> EnumerateTargetMemberDatas(ObjectMapperData mapperData)
         {
diff --git a/AgileMapper/Plans/IMappingPlan.cs b/AgileMapper/Plans/IMappingPlan.cs
new file mode 100644
index 000000000..a3c1660b2
--- /dev/null
+++ b/AgileMapper/Plans/IMappingPlan.cs
@@ -0,0 +1,6 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    internal interface IMappingPlan
+    {
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Plans/MappingPlan.cs b/AgileMapper/Plans/MappingPlan.cs
index afa6d86c4..066f1c3f1 100644
--- a/AgileMapper/Plans/MappingPlan.cs
+++ b/AgileMapper/Plans/MappingPlan.cs
@@ -19,7 +19,7 @@
     /// The type of target object to which the mapping described by the
     /// <see cref="MappingPlan{TSource,TTarget}"/> is performed.
     /// </typeparam>
-    public class MappingPlan<TSource, TTarget>
+    public class MappingPlan<TSource, TTarget> : IMappingPlan
     {
         private readonly List<MappingPlanData> _generatedPlanData;
 
diff --git a/AgileMapper/Plans/MappingPlanData.cs b/AgileMapper/Plans/MappingPlanData.cs
index 712f478dd..c477367b0 100644
--- a/AgileMapper/Plans/MappingPlanData.cs
+++ b/AgileMapper/Plans/MappingPlanData.cs
@@ -11,8 +11,6 @@
     using Extensions;
     using Members;
     using ObjectPopulation;
-    using ReadableExpressions;
-    using ReadableExpressions.Extensions;
 
     internal class MappingPlanData
     {
@@ -128,29 +126,6 @@ public override bool Equals(object obj)
         #endregion
         public override int GetHashCode() => 0;
 
-        public string GetDescription()
-        {
-            var lambda = GetFinalMappingLambda();
-
-            var sourceType = _mappingTypes.SourceType.GetFriendlyName();
-            var targetType = _mappingTypes.TargetType.GetFriendlyName();
-
-            return $@"
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-// Map {sourceType} -> {targetType}
-// Rule Set: {_mappingData.MappingContext.RuleSet.Name}
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-
-{lambda.ToReadableString()}".TrimStart();
-        }
-
-        private Expression GetFinalMappingLambda()
-        {
-            var lambdaWithEnumMismatches = EnumMappingMismatchFinder.Process(Lambda, _mappingData);
-
-            return lambdaWithEnumMismatches;
-        }
+        public string GetDescription() => MappingPlanFunction.For(Lambda, _mappingData.MapperData);
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Plans/MappingPlanFunction.cs b/AgileMapper/Plans/MappingPlanFunction.cs
new file mode 100644
index 000000000..c591305c8
--- /dev/null
+++ b/AgileMapper/Plans/MappingPlanFunction.cs
@@ -0,0 +1,35 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    using System.Linq.Expressions;
+    using ObjectPopulation;
+    using ReadableExpressions;
+    using ReadableExpressions.Extensions;
+
+    internal static class MappingPlanFunction
+    {
+        public static string For(Expression lambda, ObjectMapperData mapperData)
+        {
+            lambda = GetFinalMappingLambda(lambda, mapperData);
+
+            var sourceType = mapperData.SourceType.GetFriendlyName();
+            var targetType = mapperData.TargetType.GetFriendlyName();
+
+            return $@"
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+// Map {sourceType} -> {targetType}
+// Rule Set: {mapperData.RuleSet.Name}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+{lambda.ToReadableString()}".TrimStart();
+        }
+
+        private static Expression GetFinalMappingLambda(Expression lambda, ObjectMapperData mapperData)
+        {
+            var lambdaWithEnumMismatches = EnumMappingMismatchFinder.Process(lambda, mapperData);
+
+            return lambdaWithEnumMismatches;
+        }
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Plans/MappingPlanSet.cs b/AgileMapper/Plans/MappingPlanSet.cs
index a30ac4eb8..1d64ca902 100644
--- a/AgileMapper/Plans/MappingPlanSet.cs
+++ b/AgileMapper/Plans/MappingPlanSet.cs
@@ -5,26 +5,27 @@
     using System.Linq;
 
     /// <summary>
-    /// Contains details of the mapping plan for a mapping between a particular source and target type,
-    /// for all mapping types (create new, merge, overwrite).
+    /// Contains sets of details of mapping plans for mappings between a particular source and target types,
+    /// for particular mapping types (create new, merge, overwrite).
     /// </summary>
-    /// <typeparam name="TSource">
-    /// The type of source object from which the mapping described by the
-    /// <see cref="MappingPlanSet{TSource,TTarget}"/> is performed.
-    /// </typeparam>
-    /// <typeparam name="TTarget">
-    /// The type of target object to which the mapping described by the
-    /// <see cref="MappingPlanSet{TSource,TTarget}"/> is performed.
-    /// </typeparam>
-    public class MappingPlanSet<TSource, TTarget>
+    public class MappingPlanSet
     {
-        private readonly IEnumerable<MappingPlan<TSource, TTarget>> _mappingPlans;
+        private readonly IEnumerable<IMappingPlan> _mappingPlans;
 
-        internal MappingPlanSet(IEnumerable<MappingPlan<TSource, TTarget>> mappingPlans)
+        internal MappingPlanSet(IEnumerable<IMappingPlan> mappingPlans)
         {
             _mappingPlans = mappingPlans;
         }
 
+        internal static MappingPlanSet For(MapperContext mapperContext)
+        {
+            return new MappingPlanSet(mapperContext
+                .ObjectMapperFactory
+                .RootMappers
+                .Select(mapper => new CachedMapperMappingPlan(mapper))
+                .ToArray());
+        }
+
         /// <summary>
         /// Converts the given <paramref name="mappingPlans">MappingPlanSet</paramref> to its string 
         /// representation.
@@ -33,17 +34,17 @@ internal MappingPlanSet(IEnumerable<MappingPlan<TSource, TTarget>> mappingPlans)
         /// <returns>
         /// The string representation of the <paramref name="mappingPlans">MappingPlanSet</paramref>.
         /// </returns>
-        public static implicit operator string(MappingPlanSet<TSource, TTarget> mappingPlans)
+        public static implicit operator string(MappingPlanSet mappingPlans)
         {
             return string.Join(
                 Environment.NewLine + Environment.NewLine,
-                mappingPlans._mappingPlans.Select(plan => (string)plan));
+                mappingPlans._mappingPlans.Select(plan => plan.ToString()));
         }
 
         /// <summary>
-        /// Returns the string representation of the <see cref="MappingPlanSet{TSource,TTarget}"/>.
+        /// Returns the string representation of the <see cref="MappingPlanSet"/>.
         /// </summary>
-        /// <returns>The string representation of the <see cref="MappingPlanSet{TSource,TTarget}"/>.</returns>
+        /// <returns>The string representation of the <see cref="MappingPlanSet"/>.</returns>
         public override string ToString() => this;
     }
 }
\ No newline at end of file

From ac90a2f17b3caa982e86afdc0060c7d0239ca2d4 Mon Sep 17 00:00:00 2001
From: Steve Wilkes <steve@agileobjects.co.uk>
Date: Fri, 20 Oct 2017 17:23:46 +0100
Subject: [PATCH 8/8] Adding a GetPlansFor overload for anonymous source types

---
 .../WhenViewingMappingPlans.cs                  |  2 +-
 AgileMapper/IMapper.cs                          | 16 +++++++++++++++-
 AgileMapper/Mapper.cs                           | 17 +++++++++++++++++
 3 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index dd43315be..5b7faf92e 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -490,7 +490,7 @@ public void ShouldShowAllCachedMappingPlans()
         {
             Mapper.GetPlanFor<PublicField<string>>().ToANew<PublicProperty<int>>();
             Mapper.GetPlanFor<Customer>().ToANew<CustomerViewModel>();
-            Mapper.GetPlansFor<MegaProduct>().To<ProductDtoMega>();
+            Mapper.GetPlansFor(new MegaProduct()).To<ProductDtoMega>();
 
             var plan = Mapper.GetPlansInCache();
 
diff --git a/AgileMapper/IMapper.cs b/AgileMapper/IMapper.cs
index 6c089c68a..4a3f62a1d 100644
--- a/AgileMapper/IMapper.cs
+++ b/AgileMapper/IMapper.cs
@@ -3,7 +3,6 @@
     using System;
     using Api;
     using Api.Configuration;
-    using Plans;
 
     /// <summary>
     /// Provides mapping and mapping configuration services.
@@ -41,6 +40,21 @@ public interface IMapper : IDisposable
         /// </returns>
         IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>();
 
+        /// <summary>
+        /// Create and compile mapping functions for mapping from the source type specified by the given 
+        /// <paramref name="exampleInstance"/>, for all mapping types (create new, merge, overwrite). Use this 
+        /// overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        IPlanTargetTypeSelector GetPlansFor<TSource>(TSource exampleInstance);
+
         /// <summary>
         /// Create and compile mapping functions for the source type specified by the type argument, for all
         /// mapping types (create new, merge, overwrite).
diff --git a/AgileMapper/Mapper.cs b/AgileMapper/Mapper.cs
index dcf710ac6..68563185a 100644
--- a/AgileMapper/Mapper.cs
+++ b/AgileMapper/Mapper.cs
@@ -33,6 +33,8 @@ private Mapper(MapperContext mapperContext)
 
         IPlanTargetTypeAndRuleSetSelector<TSource> IMapper.GetPlanFor<TSource>() => GetPlan<TSource>();
 
+        IPlanTargetTypeSelector IMapper.GetPlansFor<TSource>(TSource exampleInstance) => GetPlan<TSource>();
+
         IPlanTargetTypeSelector IMapper.GetPlansFor<TSource>() => GetPlan<TSource>();
 
         string IMapper.GetPlansInCache() => MappingPlanSet.For(_mapperContext);
@@ -71,6 +73,21 @@ private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
         /// </returns>
         public static IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
 
+        /// <summary>
+        /// Create and compile mapping functions for mapping from the source type specified by the given 
+        /// <paramref name="exampleInstance"/>, for all mapping types (create new, merge, overwrite). Use this 
+        /// overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        public static IPlanTargetTypeSelector GetPlansFor<TSource>(TSource exampleInstance) => GetPlansFor<TSource>();
+
         /// <summary>
         /// Create and compile mapping functions for the source type specified by the type argument, for all
         /// mapping types (create new, merge, overwrite).