less allocations

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -3,7 +3,6 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
-using System.Security.Cryptography;
 using AutoMapper.Configuration;
 using AutoMapper.Features;
 using AutoMapper.Internal;
@@ -68,6 +67,7 @@ public class MapperConfiguration : IGlobalConfiguration
         private readonly ParameterExpression[] _parameters = new ParameterExpression[] { null, null, ContextParameter };
         private readonly CatchBlock[] _catches = new CatchBlock[1];
         private readonly List<Expression> _expressions = new();
+        private readonly Dictionary<Type, DefaultExpression> _defaults;
         public MapperConfiguration(MapperConfigurationExpression configurationExpression)
         {
             var configuration = (IGlobalConfigurationExpression)configurationExpression;
@@ -98,6 +98,7 @@ public MapperConfiguration(MapperConfigurationExpression configurationExpression
                 typeMapsCount += profileMap.TypeMapsCount;
                 openTypeMapsCount += profileMap.OpenTypeMapsCount;
             }
+            _defaults = new(3 * typeMapsCount);
             _configuredMaps = new(typeMapsCount);
             _hasOpenMaps = openTypeMapsCount > 0;
             _runtimeMaps = new(GetTypeMap, openTypeMapsCount);
@@ -110,12 +111,15 @@ public MapperConfiguration(MapperConfigurationExpression configurationExpression
             {
                 profile.Clear();
             }
+            _configuredMaps.TrimExcess();
+            _resolvedMaps.TrimExcess();
             _typeMapsPath = null;
             _sourceMembers = null;
             _expressions = null;
             _variables = null;
             _parameters = null;
             _catches = null;
+            _defaults = null;
             _sealed = true;
             return;
             void Seal()
@@ -259,6 +263,19 @@ static MapperConfigurationExpression Build(Action<IMapperConfigurationExpression
         HashSet<TypeMap> IGlobalConfiguration.TypeMapsPath => _typeMapsPath;
         ParameterExpression[] IGlobalConfiguration.Parameters => _parameters;
         CatchBlock[] IGlobalConfiguration.Catches => _catches;
+        DefaultExpression IGlobalConfiguration.GetDefault(Type type)
+        {
+            if (_defaults == null)
+            {
+                return Default(type);
+            }
+            if (!_defaults.TryGetValue(type, out var defaultExpression))
+            {
+                defaultExpression = Default(type);
+                _defaults.Add(type, defaultExpression);
+            }
+            return defaultExpression;
+        }
         Func<TSource, TDestination, ResolutionContext, TDestination> IGlobalConfiguration.GetExecutionPlan<TSource, TDestination>(in MapRequest mapRequest)
             => (Func<TSource, TDestination, ResolutionContext, TDestination>)GetExecutionPlan(mapRequest);
         private Delegate GetExecutionPlan(in MapRequest mapRequest) => _executionPlans.GetOrAdd(mapRequest);

src/AutoMapper/Configuration/TypeMapConfiguration.cs

@@ -216,8 +216,21 @@ protected void IncludeBaseCore(Type sourceBase, Type destinationBase)
             _types.CheckIsDerivedFrom(baseTypes);
             TypeMapActions.Add(tm => tm.IncludeBaseTypes(baseTypes));
         }
-        public IPropertyMapConfiguration GetDestinationMemberConfiguration(MemberInfo destinationMember) =>
-            _memberConfigurations?.Find(m => m.DestinationMember == destinationMember);
+        public IPropertyMapConfiguration GetDestinationMemberConfiguration(MemberInfo destinationMember)
+        {
+            if (_memberConfigurations == null)
+            {
+                return null;
+            }
+            foreach (var config in _memberConfigurations)
+            {
+                if (config.DestinationMember == destinationMember)
+                {
+                    return config;
+                }
+            }
+            return null;
+        }
         protected abstract void IgnoreDestinationMember(MemberInfo property, bool ignorePaths = true);
     }
     public abstract class MappingExpressionBase<TSource, TDestination, TMappingExpression> : TypeMapConfiguration, IMappingExpressionBase<TSource, TDestination, TMappingExpression>

src/AutoMapper/ConstructorMap.cs

@@ -7,6 +7,7 @@
 using System.Reflection;
 namespace AutoMapper
 {
+    using Execution;
     [EditorBrowsable(EditorBrowsableState.Never)]
     public class ConstructorMap
     {
@@ -96,7 +97,7 @@ public ConstructorParameterMap(ConstructorParameterMap parameterMap, IncludedMem
         public override IncludedMember IncludedMember { get; }
         public override MemberInfo[] SourceMembers { get; set; }
         public override string DestinationName => Parameter.Name;
-        public Expression DefaultValue() => Parameter.IsOptional ? Parameter.GetDefaultValue() : Expression.Default(DestinationType);
+        public Expression DefaultValue(IGlobalConfiguration configuration) => Parameter.IsOptional ? Parameter.GetDefaultValue(configuration) : configuration.Default(DestinationType);
         public override string ToString() => Parameter.Member.DeclaringType + "." + Parameter.Member + ".parameter " + Parameter.Name;
     }
 }

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -42,9 +42,11 @@ public static class ExpressionBuilder
         private static readonly ParameterExpression[] Indexes = new[] { Index };
         private static readonly BinaryExpression ResetIndex = Assign(Index, Zero);
         private static readonly UnaryExpression IncrementIndex = PostIncrementAssign(Index);
+        public static DefaultExpression Default(this IGlobalConfiguration configuration, Type type) =>
+            configuration == null ? Expression.Default(type) : configuration.GetDefault(type);
         public static (List<ParameterExpression> Variables, List<Expression> Expressions) ScratchPad(this IGlobalConfiguration configuration)
         {
-            var variables = configuration.Variables;
+            var variables = configuration?.Variables;
             if (variables == null)
             {
                 variables = new();
@@ -53,7 +55,7 @@ public static (List<ParameterExpression> Variables, List<Expression> Expressions
             {
                 variables.Clear();
             }
-            var expressions = configuration.Expressions;
+            var expressions = configuration?.Expressions;
             if (expressions == null)
             {
                 expressions = new();
@@ -67,7 +69,7 @@ public static (List<ParameterExpression> Variables, List<Expression> Expressions
         public static Expression MapExpression(this IGlobalConfiguration configuration, ProfileMap profileMap, TypePair typePair, Expression source,
             MemberMap memberMap = null, Expression destination = null)
         {
-            destination ??= Default(typePair.DestinationType);
+            destination ??= configuration.Default(typePair.DestinationType);
             var typeMap = configuration.ResolveTypeMap(typePair);
             Expression mapExpression = null;
             bool nullCheck;
@@ -153,7 +155,7 @@ Expression DefaultDestination()
             {
                 if ((isCollection && profileMap.AllowsNullCollectionsFor(memberMap)) || (!isCollection && profileMap.AllowsNullDestinationValuesFor(memberMap)))
                 {
-                    return destination.NodeType == ExpressionType.Default ? destination : Default(destinationType);
+                    return destination.NodeType == ExpressionType.Default ? destination : configuration.Default(destinationType);
                 }
                 if (destinationType.IsArray)
                 {
@@ -163,7 +165,7 @@ Expression DefaultDestination()
                         Expression.Call(ArrayEmptyMethod.MakeGenericMethod(destinationElementType)) :
                         NewArrayBounds(destinationElementType, Enumerable.Repeat(Zero, rank));
                 }
-                return ObjectFactory.GenerateConstructorExpression(destinationType);
+                return ObjectFactory.GenerateConstructorExpression(destinationType, configuration);
             }
         }
         public static Expression ServiceLocator(Type type) => Expression.Call(ContextParameter, ContextCreate, Constant(type));
@@ -378,7 +380,7 @@ public static Expression NullCheck(this Expression expression, IGlobalConfigurat
             var destinationType = memberMap?.DestinationType;
             var returnType = (destinationType != null && destinationType != expression.Type && Nullable.GetUnderlyingType(destinationType) == expression.Type) ?
                 destinationType : expression.Type;
-            var defaultReturn = (defaultValue is { NodeType: ExpressionType.Default } && defaultValue.Type == returnType) ? defaultValue : Default(returnType);
+            var defaultReturn = (defaultValue is { NodeType: ExpressionType.Default } && defaultValue.Type == returnType) ? defaultValue : configuration.Default(returnType);
             List<ParameterExpression> variables = null;
             List<Expression> expressions = null;
             var name = parameter.Name;

src/AutoMapper/Execution/ObjectFactory.cs

@@ -15,17 +15,17 @@ public static class ObjectFactory
         private static readonly LockingConcurrentDictionary<Type, Func<object>> CtorCache = new(GenerateConstructor);
         public static object CreateInstance(Type type) => CtorCache.GetOrAdd(type)();
         private static Func<object> GenerateConstructor(Type type) =>
-            Lambda<Func<object>>(GenerateConstructorExpression(type).ToObject()).Compile();
+            Lambda<Func<object>>(GenerateConstructorExpression(type, null).ToObject()).Compile();
         public static object CreateInterfaceProxy(Type interfaceType) => CreateInstance(ProxyGenerator.GetProxyType(interfaceType));
-        public static Expression GenerateConstructorExpression(Type type) => type switch
+        public static Expression GenerateConstructorExpression(Type type, IGlobalConfiguration configuration) => type switch
         {
-            { IsValueType: true } => Default(type),
+            { IsValueType: true } => configuration.Default(type),
             Type stringType when stringType == typeof(string) => Constant(string.Empty),
             { IsInterface: true } => CreateInterfaceExpression(type),
             { IsAbstract: true } => InvalidType(type, $"Cannot create an instance of abstract type {type}."),
-            _ => CallConstructor(type)
+            _ => CallConstructor(type, configuration)
         };
-        private static Expression CallConstructor(Type type)
+        private static Expression CallConstructor(Type type, IGlobalConfiguration configuration)
         {
             var defaultCtor = type.GetConstructor(TypeExtensions.InstanceFlags, null, Type.EmptyTypes, null);
             if (defaultCtor != null)
@@ -38,7 +38,7 @@ private static Expression CallConstructor(Type type)
             {
                 return InvalidType(type, $"{type} needs to have a constructor with 0 args or only optional args. Validate your configuration for details.");
             }
-            var arguments = ctorWithOptionalArgs.args.Select(p => p.GetDefaultValue());
+            var arguments = ctorWithOptionalArgs.args.Select(p => p.GetDefaultValue(configuration));
             return New(ctorWithOptionalArgs.ctor, arguments);
         }
         private static Expression CreateInterfaceExpression(Type type) =>