polymorphic implementation for type converters

lbargaoanu · lbargaoanu · commit ffa12680a708 · 2022-07-06T17:37:33.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()
@@ -538,4 +539,35 @@ public TMappingExpression AsProxy()
             return this as TMappingExpression;
         }
     }
+    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/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,9 @@ 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) { }
+    }
 }
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
`@@ -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
`@@ -9,6 +9,8 @@ namespace AutoMapper.Execution`
`9`	`9`	`using static Expression;`
`10`	`10`	`using static ExpressionBuilder;`
`11`	`11`	`using Internal;`
	`12`	`+ using AutoMapper.Configuration;`
	`13`	`+`
`12`	`14`	`public class TypeMapPlanBuilder`
`13`	`15`	`{`
`14`	`16`	`private static readonly MethodInfo CreateProxyMethod = typeof(ObjectFactory).GetStaticMethod(nameof(ObjectFactory.CreateInterfaceProxy));`
`@@ -33,7 +35,7 @@ public TypeMapPlanBuilder(IGlobalConfiguration configurationProvider, TypeMap ty`
`33`	`35`	`public LambdaExpression CreateMapperLambda(HashSet<TypeMap> typeMapsPath)`
`34`	`36`	`{`
`35`	`37`	`var parameters = new[] { Source, _initialDestination, ContextParameter };`
`36`		`- var customExpression = TypeConverter(parameters) ?? (_typeMap.CustomMapFunction ?? _typeMap.CustomMapExpression)?.ConvertReplaceParameters(parameters);`
	`38`	`+ var customExpression = _typeMap.TypeConverter?.GetExpression(parameters);`
`37`	`39`	`if (customExpression != null)`
`38`	`40`	`{`
`39`	`41`	`return Lambda(customExpression, parameters);`
`@@ -61,16 +63,6 @@ public LambdaExpression CreateMapperLambda(HashSet<TypeMap> typeMapsPath)`
`61`	`63`	`statements.Add(mapperFunc);`
`62`	`64`	`variables.Add(_destination);`
`63`	`65`	`return Lambda(Block(variables, statements), parameters);`
`64`		`- Expression TypeConverter(ParameterExpression[] parameters)`
`65`		`- {`
`66`		`- if (_typeMap.TypeConverterType == null)`
`67`		`- {`
`68`		`- return null;`
`69`		`- }`
`70`		`- var converterInterfaceType = typeof(ITypeConverter<,>).MakeGenericType(_typeMap.SourceType, DestinationType);`
`71`		`- var converter = ServiceLocator(_typeMap.TypeConverterType);`
`72`		`- return Call(ToType(converter, converterInterfaceType), "Convert", parameters);`
`73`		`- }`
`74`	`66`	`static void Clear(ref HashSet<TypeMap> typeMapsPath)`
`75`	`67`	`{`
`76`	`68`	`if (typeMapsPath == null)`
`@@ -423,7 +415,6 @@ static Expression CustomMapExpression(Expression mapFrom, Type destinationProper`
`423`	`415`	`}`
`424`	`416`	`}`
`425`	`417`	`private Expression GetCustomSource(MemberMap memberMap) => memberMap.IncludedMember?.Variable ?? Source;`
`426`		`- private static Expression ServiceLocator(Type type) => Call(ContextParameter, ContextCreate, Constant(type));`
`427`	`418`	`private Expression BuildResolveCall(MemberMap memberMap, Expression source, Expression destValueExpr)`
`428`	`419`	`{`
`429`	`420`	`var typeMap = memberMap.TypeMap;`
`@@ -466,4 +457,9 @@ AutoMapperConfigurationException BuildExceptionMessage()`
`466`	`457`	`=> 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.");`
`467`	`458`	`}`
`468`	`459`	`}`
	`460`	`+ public abstract class TypeConverter`
	`461`	`+ {`
	`462`	`+ public abstract Expression GetExpression(ParameterExpression[] parameters);`
	`463`	`+ public virtual void CloseGenerics(ITypeMapConfiguration openMapConfig, TypePair closedTypes) { }`
	`464`	`+ }`
`469`	`465`	`}`
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);`