polymorphic implementation for type converters

lbargaoanu · lbargaoanu · commit ba60290f083f · 2022-07-07T09:25:15.000+03:00
diff --git a/src/AutoMapper/Configuration/MappingExpressionBase.cs b/src/AutoMapper/Configuration/MappingExpressionBase.cs
@@ -9,6 +9,7 @@
 namespace AutoMapper.Configuration
 {
     using static Expression;
+    using static Execution.ExpressionBuilder;
     using Execution;
     [EditorBrowsable(EditorBrowsableState.Never)]
     public interface ITypeMapConfiguration
@@ -456,18 +457,16 @@ public TMappingExpression ConstructUsing(Func<TSource, ResolutionContext, TDesti
         public void ConvertUsing(Type typeConverterType)
         {
             HasTypeConverter = true;
-            TypeMapActions.Add(tm => tm.TypeConverterType = typeConverterType);
+            TypeMapActions.Add(tm => tm.TypeConverter = new ClassTypeConverter(Types, typeConverterType));
         }
 
         public void ConvertUsing(Func<TSource, TDestination, TDestination> mappingFunction)
         {
             HasTypeConverter = true;
             TypeMapActions.Add(tm =>
             {
-                Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr =
-                    (src, dest, ctxt) => mappingFunction(src, dest);
-
-                tm.CustomMapFunction = expr;
+                Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr = (src, dest, ctxt) => mappingFunction(src, dest);
+                tm.TypeConverter = new LambdaTypeConverter(expr);
             });
         }
 
@@ -476,10 +475,8 @@ public void ConvertUsing(Func<TSource, TDestination, ResolutionContext, TDestina
             HasTypeConverter = true;
             TypeMapActions.Add(tm =>
             {
-                Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr =
-                    (src, dest, ctxt) => mappingFunction(src, dest, ctxt);
-
-                tm.CustomMapFunction = expr;
+                Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr = (src, dest, ctxt) => mappingFunction(src, dest, ctxt);
+                tm.TypeConverter = new LambdaTypeConverter(expr);
             });
         }
 
@@ -488,7 +485,7 @@ public void ConvertUsing(Func<TSource, TDestination, ResolutionContext, TDestina
         public void ConvertUsing<TTypeConverter>() where TTypeConverter : ITypeConverter<TSource, TDestination>
         {
             HasTypeConverter = true;
-            TypeMapActions.Add(tm => tm.TypeConverterType = typeof(TTypeConverter));
+            TypeMapActions.Add(tm => tm.TypeConverter = new ClassTypeConverter(Types, typeof(TTypeConverter), typeof(ITypeConverter<TSource, TDestination>)));
         }
 
         public TMappingExpression ForCtorParam(string ctorParamName, Action<ICtorParamConfigurationExpression<TSource>> paramOptions)
@@ -525,7 +522,11 @@ public TMappingExpression IgnoreAllSourcePropertiesWithAnInaccessibleSetter()
         public void ConvertUsing(Expression<Func<TSource, TDestination>> mappingFunction)
         {
             HasTypeConverter = true;
-            TypeMapActions.Add(tm => tm.CustomMapExpression = mappingFunction);
+            TypeMapActions.Add(tm =>
+            {
+                tm.CustomMapExpression = mappingFunction;
+                tm.TypeConverter = new LambdaTypeConverter(mappingFunction);
+            });
         }
 
         public TMappingExpression AsProxy()
diff --git a/src/AutoMapper/Execution/ExpressionBuilder.cs b/src/AutoMapper/Execution/ExpressionBuilder.cs
@@ -26,7 +26,7 @@ public static class ExpressionBuilder
         public static readonly MethodInfo IListAdd = typeof(IList).GetMethod(nameof(IList.Add));
         public static readonly MethodInfo IncTypeDepthInfo = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.IncrementTypeDepth));
         public static readonly MethodInfo DecTypeDepthInfo = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.DecrementTypeDepth));
-        public static readonly MethodInfo ContextCreate = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.CreateInstance));
+        private static readonly MethodInfo ContextCreate = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.CreateInstance));
         public static readonly MethodInfo OverTypeDepthMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.OverTypeDepth));
         public static readonly MethodInfo CacheDestinationMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.CacheDestination));
         public static readonly MethodInfo GetDestinationMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.GetDestination));
@@ -133,6 +133,7 @@ Expression DefaultDestination()
                 return ObjectFactory.GenerateConstructorExpression(destinationType);
             }
         }
+        public static Expression ServiceLocator(Type type) => Expression.Call(ContextParameter, ContextCreate, Constant(type));
         public static Expression ContextMap(TypePair typePair, Expression sourceParameter, Expression destinationParameter, MemberMap memberMap)
         {
             var mapMethod = ContextMapMethod.MakeGenericMethod(typePair.SourceType, typePair.DestinationType);
diff --git a/src/AutoMapper/Execution/TypeMapPlanBuilder.cs b/src/AutoMapper/Execution/TypeMapPlanBuilder.cs
@@ -9,6 +9,8 @@ namespace AutoMapper.Execution
     using static Expression;
     using static ExpressionBuilder;
     using Internal;
+    using AutoMapper.Configuration;
+
     public class TypeMapPlanBuilder
     {
         private static readonly MethodInfo CreateProxyMethod = typeof(ObjectFactory).GetStaticMethod(nameof(ObjectFactory.CreateInterfaceProxy));
@@ -33,7 +35,7 @@ public TypeMapPlanBuilder(IGlobalConfiguration configurationProvider, TypeMap ty
         public LambdaExpression CreateMapperLambda(HashSet<TypeMap> typeMapsPath)
         {
             var parameters = new[] { Source, _initialDestination, ContextParameter };
-            var customExpression = TypeConverter(parameters) ?? (_typeMap.CustomMapFunction ?? _typeMap.CustomMapExpression)?.ConvertReplaceParameters(parameters);
+            var customExpression = _typeMap.TypeConverter?.GetExpression(parameters);
             if (customExpression != null)
             {
                 return Lambda(customExpression, parameters);
@@ -61,16 +63,6 @@ public LambdaExpression CreateMapperLambda(HashSet<TypeMap> typeMapsPath)
             statements.Add(mapperFunc);
             variables.Add(_destination);
             return Lambda(Block(variables, statements), parameters);
-            Expression TypeConverter(ParameterExpression[] parameters)
-            {
-                if (_typeMap.TypeConverterType == null)
-                {
-                    return null;
-                }
-                var converterInterfaceType = typeof(ITypeConverter<,>).MakeGenericType(_typeMap.SourceType, DestinationType);
-                var converter = ServiceLocator(_typeMap.TypeConverterType);
-                return Call(ToType(converter, converterInterfaceType), "Convert", parameters);
-            }
             static void Clear(ref HashSet<TypeMap> typeMapsPath)
             {
                 if (typeMapsPath == null)
@@ -423,7 +415,6 @@ static Expression CustomMapExpression(Expression mapFrom, Type destinationProper
             }
         }
         private Expression GetCustomSource(MemberMap memberMap) => memberMap.IncludedMember?.Variable ?? Source;
-        private static Expression ServiceLocator(Type type) => Call(ContextParameter, ContextCreate, Constant(type));
         private Expression BuildResolveCall(MemberMap memberMap, Expression source, Expression destValueExpr)
         {
             var typeMap = memberMap.TypeMap;
@@ -466,4 +457,40 @@ AutoMapperConfigurationException BuildExceptionMessage()
                 => new AutoMapperConfigurationException($"Cannot find a source member to pass to the value converter of type {valueConverterConfig.ConcreteType.FullName}. Configure a source member to map from.");
         }
     }
+    public abstract class TypeConverter
+    {
+        public abstract Expression GetExpression(ParameterExpression[] parameters);
+        public virtual void CloseGenerics(ITypeMapConfiguration openMapConfig, TypePair closedTypes) { }
+    }
+    public class LambdaTypeConverter : TypeConverter
+    {
+        public LambdaTypeConverter(LambdaExpression lambda) => Lambda = lambda;
+        public LambdaExpression Lambda { get; }
+        public override Expression GetExpression(ParameterExpression[] parameters) => Lambda.ConvertReplaceParameters(parameters);
+    }
+    public class ClassTypeConverter : TypeConverter
+    {
+        public ClassTypeConverter(TypePair types, Type converterType, Type converterInterface)
+        {
+            Types = types;
+            ConverterType = converterType;
+            ConverterInterface = converterInterface;
+        }
+        public ClassTypeConverter(TypePair types, Type converterType) : this(types, converterType, types.ContainsGenericParameters ? null : types.ITypeConverter())
+        {
+        }
+        public TypePair Types { get; }
+        public Type ConverterType { get; private set; }
+        public Type ConverterInterface { get; private set; }
+        public override Expression GetExpression(ParameterExpression[] parameters) =>
+            Call(ToType(ServiceLocator(ConverterType), ConverterInterface), "Convert", parameters);
+        public override void CloseGenerics(ITypeMapConfiguration openMapConfig, TypePair closedTypes)
+        {
+            var typeParams = (openMapConfig.SourceType.IsGenericTypeDefinition ? closedTypes.SourceType.GenericTypeArguments : Type.EmptyTypes)
+                .Concat(openMapConfig.DestinationType.IsGenericTypeDefinition ? closedTypes.DestinationType.GenericTypeArguments : Type.EmptyTypes);
+            var neededParameters = ConverterType.GenericParametersCount();
+            ConverterType = ConverterType.MakeGenericType(typeParams.Take(neededParameters).ToArray());
+            ConverterInterface = closedTypes.ITypeConverter();
+        }
+    }
 }
diff --git a/src/AutoMapper/Internal/TypePair.cs b/src/AutoMapper/Internal/TypePair.cs
@@ -53,6 +53,7 @@ public TypePair CloseGenericTypes(TypePair closedTypes)
             var closedDestinationType = DestinationType.IsGenericTypeDefinition ? DestinationType.MakeGenericType(destinationArguments) : DestinationType;
             return new TypePair(closedSourceType, closedDestinationType);
         }
+        public Type ITypeConverter() => typeof(ITypeConverter<,>).MakeGenericType(SourceType, DestinationType);
         public TypePair GetTypeDefinitionIfGeneric() => new TypePair(GetTypeDefinitionIfGeneric(SourceType), GetTypeDefinitionIfGeneric(DestinationType));
         private static Type GetTypeDefinitionIfGeneric(Type type) => type.IsGenericType ? type.GetGenericTypeDefinition() : type;
         public static bool operator ==(TypePair left, TypePair right) => left.Equals(right);
diff --git a/src/AutoMapper/ProfileMap.cs b/src/AutoMapper/ProfileMap.cs
@@ -206,19 +206,8 @@ public TypeMap CreateClosedGenericTypeMap(ITypeMapConfiguration openMapConfig, T
                 closedMap = new TypeMap(closedTypes.SourceType, closedTypes.DestinationType, this, openMapConfig);
             }
             openMapConfig.Configure(closedMap);
-            Configure(closedMap, configurationProvider);
-            if (closedMap.TypeConverterType != null)
-            {
-                var typeParams = (openMapConfig.SourceType.IsGenericTypeDefinition ? closedTypes.SourceType.GenericTypeArguments : Type.EmptyTypes)
-                    .Concat(openMapConfig.DestinationType.IsGenericTypeDefinition ? closedTypes.DestinationType.GenericTypeArguments : Type.EmptyTypes);
-                var neededParameters = closedMap.TypeConverterType.GenericParametersCount();
-                closedMap.TypeConverterType = closedMap.TypeConverterType.MakeGenericType(typeParams.Take(neededParameters).ToArray());
-            }
-            if (closedMap.DestinationTypeOverride is { IsGenericTypeDefinition: true })
-            {
-                var neededParameters = closedMap.DestinationTypeOverride.GenericParametersCount();
-                closedMap.DestinationTypeOverride = closedMap.DestinationTypeOverride.MakeGenericType(closedTypes.DestinationType.GenericTypeArguments.Take(neededParameters).ToArray());
-            }
+            Configure(closedMap, configurationProvider);
+            closedMap.CloseGenerics(openMapConfig, closedTypes);
             return closedMap;
         }
         public ITypeMapConfiguration GetGenericMap(TypePair genericPair) => _openTypeMapConfigs.GetValueOrDefault(genericPair);
diff --git a/src/AutoMapper/TypeMap.cs b/src/AutoMapper/TypeMap.cs
@@ -48,7 +48,7 @@ public TypeMap(Type sourceType, Type destinationType, ProfileMap profile, ITypeM
             {
                 sourceMembers.Clear();
                 var propertyType = destinationProperty.GetMemberType();
-                if (profile.MapDestinationPropertyToSource(SourceTypeDetails, destinationType, propertyType, destinationProperty.Name, sourceMembers, 
+                if (profile.MapDestinationPropertyToSource(SourceTypeDetails, destinationType, propertyType, destinationProperty.Name, sourceMembers,
                         typeMapConfiguration?.IsReverseMap is true))
                 {
                     AddPropertyMap(destinationProperty, propertyType, sourceMembers);
@@ -85,12 +85,11 @@ internal bool CanConstructorMap() => Profile.ConstructorMappingEnabled && !Desti
         public Type SourceType => Types.SourceType;
         public Type DestinationType => Types.DestinationType;
         public ProfileMap Profile { get; }
-        public LambdaExpression CustomMapFunction { get; set; }
         public LambdaExpression CustomMapExpression { get; set; }
         public LambdaExpression CustomCtorFunction { get; set; }
         public LambdaExpression CustomCtorExpression { get; set; }
         public Type DestinationTypeOverride
-        { 
+        {
             get => _destinationTypeOverride;
             set
             {
@@ -109,7 +108,6 @@ public Type DestinationTypeOverride
         public IReadOnlyCollection<ValueTransformerConfiguration> ValueTransformers => _valueTransformerConfigs.NullCheck();
         public bool PreserveReferences { get; set; }
         public int MaxDepth { get; set; }
-        public Type TypeConverterType { get; set; }
         public bool DisableConstructorValidation { get; set; }
         public IReadOnlyCollection<PropertyMap> PropertyMaps => _orderedPropertyMaps ?? (_propertyMaps?.Values).NullCheck();
         public IReadOnlyCollection<PathMap> PathMaps => (_pathMaps?.Values).NullCheck();
@@ -144,7 +142,8 @@ public IEnumerable<MemberMap> MemberMaps
         public ConstructorParameters[] DestinationConstructors => DestinationTypeDetails.Constructors;
         public bool ConstructorMapping => ConstructorMap is { CanResolve: true };
         public bool CustomConstruction => (CustomCtorExpression ?? CustomCtorFunction) != null;
-        public bool HasTypeConverter => (CustomMapFunction ?? CustomMapExpression ?? (object)TypeConverterType) != null;
+        public bool HasTypeConverter => TypeConverter != null;
+        public TypeConverter TypeConverter { get; set; }
         public bool ShouldCheckForValid =>
             !HasTypeConverter
             && DestinationTypeOverride == null
@@ -194,7 +193,7 @@ public string[] GetUnmappedPropertyNames()
                     .Select(p => p.Name)
                     .Except(MappedMembers().Select(m => m.GetSourceMemberName()))
                     .Except(IncludedMembersNames)
-                    .Except(IncludedMembers.Select(m=>m.GetMember()?.Name))
+                    .Except(IncludedMembers.Select(m => m.GetMember()?.Name))
                     .Except(ignoredSourceMembers ?? Array.Empty<string>());
             }
             return properties.Where(memberName => !Profile.GlobalIgnores.Any(memberName.StartsWith)).ToArray();
@@ -463,5 +462,14 @@ internal void CopyInheritedMapsTo(TypeMap typeMap)
             typeMap._inheritedTypeMaps ??= new();
             typeMap._inheritedTypeMaps.UnionWith(_inheritedTypeMaps);
         }
+        public void CloseGenerics(ITypeMapConfiguration openMapConfig, TypePair closedTypes)
+        {
+            TypeConverter?.CloseGenerics(openMapConfig, closedTypes);
+            if (DestinationTypeOverride is { IsGenericTypeDefinition: true })
+            {
+                var neededParameters = DestinationTypeOverride.GenericParametersCount();
+                DestinationTypeOverride = DestinationTypeOverride.MakeGenericType(closedTypes.DestinationType.GenericTypeArguments.Take(neededParameters).ToArray());
+            }
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`namespace AutoMapper.Configuration`
`10`	`10`	`{`
`11`	`11`	`using static Expression;`
	`12`	`+ using static Execution.ExpressionBuilder;`
`12`	`13`	`using Execution;`
`13`	`14`	`[EditorBrowsable(EditorBrowsableState.Never)]`
`14`	`15`	`public interface ITypeMapConfiguration`
`@@ -456,18 +457,16 @@ public TMappingExpression ConstructUsing(Func<TSource, ResolutionContext, TDesti`
`456`	`457`	`public void ConvertUsing(Type typeConverterType)`
`457`	`458`	`{`
`458`	`459`	`HasTypeConverter = true;`
`459`		`- TypeMapActions.Add(tm => tm.TypeConverterType = typeConverterType);`
	`460`	`+ TypeMapActions.Add(tm => tm.TypeConverter = new ClassTypeConverter(Types, typeConverterType));`
`460`	`461`	`}`
`461`	`462`
`462`	`463`	`public void ConvertUsing(Func<TSource, TDestination, TDestination> mappingFunction)`
`463`	`464`	`{`
`464`	`465`	`HasTypeConverter = true;`
`465`	`466`	`TypeMapActions.Add(tm =>`
`466`	`467`	`{`
`467`		`- Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr =`
`468`		`- (src, dest, ctxt) => mappingFunction(src, dest);`
`469`		`-`
`470`		`- tm.CustomMapFunction = expr;`
	`468`	`+ Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr = (src, dest, ctxt) => mappingFunction(src, dest);`
	`469`	`+ tm.TypeConverter = new LambdaTypeConverter(expr);`
`471`	`470`	`});`
`472`	`471`	`}`
`473`	`472`
`@@ -476,10 +475,8 @@ public void ConvertUsing(Func<TSource, TDestination, ResolutionContext, TDestina`
`476`	`475`	`HasTypeConverter = true;`
`477`	`476`	`TypeMapActions.Add(tm =>`
`478`	`477`	`{`
`479`		`- Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr =`
`480`		`- (src, dest, ctxt) => mappingFunction(src, dest, ctxt);`
`481`		`-`
`482`		`- tm.CustomMapFunction = expr;`
	`478`	`+ Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr = (src, dest, ctxt) => mappingFunction(src, dest, ctxt);`
	`479`	`+ tm.TypeConverter = new LambdaTypeConverter(expr);`
`483`	`480`	`});`
`484`	`481`	`}`
`485`	`482`
`@@ -488,7 +485,7 @@ public void ConvertUsing(Func<TSource, TDestination, ResolutionContext, TDestina`
`488`	`485`	`public void ConvertUsing<TTypeConverter>() where TTypeConverter : ITypeConverter<TSource, TDestination>`
`489`	`486`	`{`
`490`	`487`	`HasTypeConverter = true;`
`491`		`- TypeMapActions.Add(tm => tm.TypeConverterType = typeof(TTypeConverter));`
	`488`	`+ TypeMapActions.Add(tm => tm.TypeConverter = new ClassTypeConverter(Types, typeof(TTypeConverter), typeof(ITypeConverter<TSource, TDestination>)));`
`492`	`489`	`}`
`493`	`490`
`494`	`491`	`public TMappingExpression ForCtorParam(string ctorParamName, Action<ICtorParamConfigurationExpression<TSource>> paramOptions)`
`@@ -525,7 +522,11 @@ public TMappingExpression IgnoreAllSourcePropertiesWithAnInaccessibleSetter()`
`525`	`522`	`public void ConvertUsing(Expression<Func<TSource, TDestination>> mappingFunction)`
`526`	`523`	`{`
`527`	`524`	`HasTypeConverter = true;`
`528`		`- TypeMapActions.Add(tm => tm.CustomMapExpression = mappingFunction);`
	`525`	`+ TypeMapActions.Add(tm =>`
	`526`	`+ {`
	`527`	`+ tm.CustomMapExpression = mappingFunction;`
	`528`	`+ tm.TypeConverter = new LambdaTypeConverter(mappingFunction);`
	`529`	`+ });`
`529`	`530`	`}`
`530`	`531`
`531`	`532`	`public TMappingExpression AsProxy()`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public static class ExpressionBuilder`
`26`	`26`	`public static readonly MethodInfo IListAdd = typeof(IList).GetMethod(nameof(IList.Add));`
`27`	`27`	`public static readonly MethodInfo IncTypeDepthInfo = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.IncrementTypeDepth));`
`28`	`28`	`public static readonly MethodInfo DecTypeDepthInfo = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.DecrementTypeDepth));`
`29`		`- public static readonly MethodInfo ContextCreate = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.CreateInstance));`
	`29`	`+ private static readonly MethodInfo ContextCreate = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.CreateInstance));`
`30`	`30`	`public static readonly MethodInfo OverTypeDepthMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.OverTypeDepth));`
`31`	`31`	`public static readonly MethodInfo CacheDestinationMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.CacheDestination));`
`32`	`32`	`public static readonly MethodInfo GetDestinationMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.GetDestination));`
`@@ -133,6 +133,7 @@ Expression DefaultDestination()`
`133`	`133`	`return ObjectFactory.GenerateConstructorExpression(destinationType);`
`134`	`134`	`}`
`135`	`135`	`}`
	`136`	`+ public static Expression ServiceLocator(Type type) => Expression.Call(ContextParameter, ContextCreate, Constant(type));`
`136`	`137`	`public static Expression ContextMap(TypePair typePair, Expression sourceParameter, Expression destinationParameter, MemberMap memberMap)`
`137`	`138`	`{`
`138`	`139`	`var mapMethod = ContextMapMethod.MakeGenericMethod(typePair.SourceType, typePair.DestinationType);`
Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,7 @@ public TypePair CloseGenericTypes(TypePair closedTypes)`
`53`	`53`	`var closedDestinationType = DestinationType.IsGenericTypeDefinition ? DestinationType.MakeGenericType(destinationArguments) : DestinationType;`
`54`	`54`	`return new TypePair(closedSourceType, closedDestinationType);`
`55`	`55`	`}`
	`56`	`+ public Type ITypeConverter() => typeof(ITypeConverter<,>).MakeGenericType(SourceType, DestinationType);`
`56`	`57`	`public TypePair GetTypeDefinitionIfGeneric() => new TypePair(GetTypeDefinitionIfGeneric(SourceType), GetTypeDefinitionIfGeneric(DestinationType));`
`57`	`58`	`private static Type GetTypeDefinitionIfGeneric(Type type) => type.IsGenericType ? type.GetGenericTypeDefinition() : type;`
`58`	`59`	`public static bool operator ==(TypePair left, TypePair right) => left.Equals(right);`