Fix root cause of inheritance bug

Author: stle-rc

LinkIt.AutoMapperExtensions.Tests/IConfigurationExtensionsTests.cs

@@ -0,0 +1,74 @@
+using System;
+using AutoMapper;
+using LinkIt.AutoMapperExtensions.Config;
+using NUnit.Framework;
+
+namespace LinkIt.AutoMapperExtensions.Tests {
+    [TestFixture]
+    public class IConfigurationExtensionsTests {
+        [Test]
+        public void Initialize_WithAbstractTransformConfig_ShouldInitializedAbstractTransformConfigFirst() {
+            Mapper.Initialize(
+                configuration => configuration.ApplyTransformConfigs(
+                    new[] { typeof(IConfigurationExtensionsTests).Assembly }
+                )
+            );
+
+            Mapper.AssertConfigurationIsValid();
+
+            //Two tests in one method because Mapper initialization is static
+            var source = new Model{
+                NotByConvention = new Uri("http://from-model.com/index.html")
+            };
+            var actual = Mapper.Map<Dto>(source);
+
+            Assert.That(actual.FromInterface.ToString(), Is.EqualTo("http://from-interface.com/index.html"));
+            Assert.That(actual.FromModel.ToString(), Is.EqualTo("http://from-model.com/index.html"));
+        }
+
+        public interface IDto
+        {
+            Uri FromInterface { get; set; }
+        }
+        public class Dto : IDto
+        {
+            public Uri FromInterface { get; set; }
+            public Uri FromModel { get; set; }
+        }
+
+        public interface IModel
+        {
+        }
+
+        public class Model:IModel
+        {
+            public Uri NotByConvention { get; set; }
+        }
+
+        public class BBeforeA_IInterfaceConfig : IAbstractTransformConfig
+        {
+            public void ConfigureTransformation(IConfiguration config)
+            {
+                config.CreateMap<IModel, IDto>()
+                    .Include<Model, Dto>()
+                    .ForMember(
+                            dto => dto.FromInterface,
+                            member => member.UseValue(new Uri("http://from-interface.com/index.html"))
+                    );
+            }
+        }
+
+        public class ABeforeB_ModelConfig : ITransformConfig {
+            public void ConfigureTransformation(IConfiguration config) {
+                config.CreateMap<Model, Dto>()
+                    .ForMember(
+                            dto => dto.FromModel,
+                            member => member.MapFrom(source=>source.NotByConvention)
+                    );
+
+            }
+        }
+
+
+    }
+}

LinkIt.AutoMapperExtensions.Tests/LinkIt.AutoMapperExtensions.Tests.csproj

@@ -57,6 +57,7 @@
     <Compile Include="AutoMapReference_PolymorphismTests.cs" />
     <Compile Include="AutoMapReference_PreconditionsTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="IConfigurationExtensionsTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

LinkIt.AutoMapperExtensions/Config/IAbstractTransformConfig.cs

@@ -0,0 +1,26 @@
+using AutoMapper;
+
+namespace LinkIt.AutoMapperExtensions.Config
+{
+    //!!! WARNING: Inherited mappings are error-prone !!!
+    //
+    //The problem is with 
+    //1)Inherited Explicit Mapping having a higher priority than Convention Mapping
+    //  For example, if a default is configured at the abstract level, 
+    //  it is easy to forget to map the property at the implementation level.
+    //2)Inherited Ignore Property are error-prone: 
+    //  ignore property at the abstract type level should not be inherited, because it easy to 
+    //  forget to map the property at the implementation level
+    //
+    //Mapping priorities from the highest to the lowest priority
+    //- Explicit Mapping (using .MapFrom())
+    //- Inherited Explicit Mapping
+    //- Ignore Property Mapping
+    //- Convention Mapping (Properties that are matched via convention)
+    //- Inherited Ignore Property Mapping
+    //Source: https://github.com/AutoMapper/AutoMapper/wiki/Mapping-inheritance
+    //
+    public interface IAbstractTransformConfig : ITransformConfig
+    {
+    }
+}

LinkIt.AutoMapperExtensions/Config/IConfigurationExtensions.cs

@@ -2,14 +2,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using AutoMapper;
 
 namespace LinkIt.AutoMapperExtensions.Config {
     public static class IConfigurationExtensions {
 
-        public static void ApplyLoadLinkProtocolConfigs(this IConfiguration config, IEnumerable<Assembly> assemblies) {
+        public static void ApplyTransformConfigs(this IConfiguration config, IEnumerable<Assembly> assemblies) {
             if (config == null) { throw new ArgumentNullException("config"); }
             if (assemblies == null) { throw new ArgumentNullException("assemblies"); }
 
@@ -19,6 +17,7 @@ public static void ApplyLoadLinkProtocolConfigs(this IConfiguration config, IEnu
                 .ToList();
 
             var transformConfigs = transformConfigTypes
+                .OrderBy(GetOrderByPriorityKey)
                 .Select(Activator.CreateInstance)
                 .Cast<ITransformConfig>()
                 .ToList();
@@ -27,5 +26,26 @@ public static void ApplyLoadLinkProtocolConfigs(this IConfiguration config, IEnu
                 transformConfig.ConfigureTransformation(config);
             }
         }
+
+        private static string GetOrderByPriorityKey(Type transformConfigType) {
+            return string.Format(
+                "{0}-{1}",
+                GetTransformConfigPriority(transformConfigType),
+                transformConfigType.FullName
+            );
+        }
+
+        private static int GetTransformConfigPriority(Type transformConfigType)
+        {
+            //IAbstractTransformConfig must be configure before ITransformConfig
+            //because otherwise the mapping defined at the abstract level are ignored
+            //at the implementation level.
+            //
+            //See WARNING: Inherited mappings are error-prone before using IAbstractTransformConfig
+
+            return transformConfigType.GetInterface("LinkIt.AutoMapperExtensions.Config.IAbstractTransformConfig") != null
+                ? 1
+                : 2;
+        }
     }
 }

LinkIt.AutoMapperExtensions/LinkIt.AutoMapperExtensions.csproj

@@ -52,6 +52,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Config\IConfigurationExtensions.cs" />
+    <Compile Include="Config\IAbstractTransformConfig.cs" />
     <Compile Include="Config\ITransformConfig.cs" />
     <Compile Include="LinkSourceMapper.cs" />
     <Compile Include="MappingExpressionExtensions.cs" />