cosmetic

src/AutoMapper/ApiCompatBaseline.txt

@@ -25,6 +25,10 @@ MembersMustExist : Member 'public System.String AutoMapper.LowerUnderscoreNaming
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.LowerUnderscoreNamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.String AutoMapper.PascalCaseNamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.PascalCaseNamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
+CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.CompilerGeneratedAttribute' exists on 'AutoMapper.Profile.DestinationMemberNamingConvention.get()' in the contract but not the implementation.
+CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.CompilerGeneratedAttribute' exists on 'AutoMapper.Profile.DestinationMemberNamingConvention.set(AutoMapper.INamingConvention)' in the contract but not the implementation.
+CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.CompilerGeneratedAttribute' exists on 'AutoMapper.Profile.SourceMemberNamingConvention.get()' in the contract but not the implementation.
+CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.CompilerGeneratedAttribute' exists on 'AutoMapper.Profile.SourceMemberNamingConvention.set(AutoMapper.INamingConvention)' in the contract but not the implementation.
 MembersMustExist : Member 'public AutoMapper.IMappingOperationOptions AutoMapper.ResolutionContext.Options.get()' does not exist in the implementation but it does exist in the contract.
 TypesMustExist : Type 'AutoMapper.ValueResolverConfiguration' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Linq.Expressions.LambdaExpression System.Linq.Expressions.LambdaExpression AutoMapper.ValueTransformerConfiguration.TransformerExpression' does not exist in the implementation but it does exist in the contract.
@@ -46,6 +50,8 @@ CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMappe
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.UseExistingValueAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.ValueConverterAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.ValueResolverAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
+MembersMustExist : Member 'public System.Collections.Generic.List<System.String> AutoMapper.Configuration.Conventions.PrePostfixName.Postfixes.get()' does not exist in the implementation but it does exist in the contract.
+MembersMustExist : Member 'public System.Collections.Generic.List<System.String> AutoMapper.Configuration.Conventions.PrePostfixName.Prefixes.get()' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Linq.Expressions.Expression System.Linq.Expressions.Expression AutoMapper.Execution.Member.Expression' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Linq.Expressions.Expression System.Linq.Expressions.Expression AutoMapper.Execution.Member.Target' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Reflection.MemberInfo System.Reflection.MemberInfo AutoMapper.Execution.Member.MemberInfo' does not exist in the implementation but it does exist in the contract.
@@ -88,4 +94,4 @@ MembersMustExist : Member 'public AutoMapper.Internal.TypePair AutoMapper.Intern
 MembersMustExist : Member 'public System.Linq.IQueryable<TDestination> AutoMapper.QueryableExtensions.Extensions.Map<TSource, TDestination>(System.Linq.IQueryable<TSource>, System.Linq.IQueryable<TDestination>, AutoMapper.IConfigurationProvider)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<System.Reflection.MemberInfo> AutoMapper.QueryableExtensions.MemberVisitor.MemberPath.get()' does not exist in the implementation but it does exist in the contract.
 TypesMustExist : Type 'AutoMapper.QueryableExtensions.Impl.MemberAccessQueryMapperVisitor' does not exist in the implementation but it does exist in the contract.
-Total Issues: 89
+Total Issues: 95

src/AutoMapper/Configuration/ConfigurationValidator.cs

@@ -6,29 +6,23 @@
 using AutoMapper.Internal.Mappers;
 namespace AutoMapper.Configuration
 {
-    using Validator = Action<ValidationContext>;
     [EditorBrowsable(EditorBrowsableState.Never)]
     public class ConfigurationValidator
     {
         private readonly IGlobalConfiguration _config;
         private readonly IGlobalConfigurationExpression _expression;
-        private readonly Validator[] _validators;
-
         public ConfigurationValidator(IGlobalConfiguration config, IGlobalConfigurationExpression expression)
         {
-            _validators = expression.GetValidators();
             _config = config;
             _expression = expression;
         }
-
         private void Validate(ValidationContext context)
         {
-            foreach (var validator in _validators)
+            foreach (var validator in _expression.GetValidators())
             {
                 validator(context);
             }
         }
-
         public void AssertConfigurationExpressionIsValid(IEnumerable<TypeMap> typeMaps)
         {
             if (!_expression.AllowAdditiveTypeMapCreation)
@@ -47,7 +41,6 @@ public void AssertConfigurationExpressionIsValid(IEnumerable<TypeMap> typeMaps)
             }
             AssertConfigurationIsValid(typeMaps);
         }
-
         public void AssertConfigurationIsValid(IEnumerable<TypeMap> typeMaps)
         {
             var maps = typeMaps as TypeMap[] ?? typeMaps.ToArray();
@@ -64,10 +57,8 @@ where unmappedPropertyNames.Length > 0 || !canConstruct
             {
                 throw new AutoMapperConfigurationException(badTypeMaps);
             }
-
             var typeMapsChecked = new List<TypeMap>();
             var configExceptions = new List<Exception>();
-
             foreach (var typeMap in maps)
             {
                 try
@@ -79,7 +70,6 @@ where unmappedPropertyNames.Length > 0 || !canConstruct
                     configExceptions.Add(e);
                 }
             }
-
             if (configExceptions.Count > 1)
             {
                 throw new AggregateException(configExceptions);
@@ -89,7 +79,6 @@ where unmappedPropertyNames.Length > 0 || !canConstruct
                 throw configExceptions[0];
             }
         }
-
         private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types, TypeMap typeMap, MemberMap memberMap)
         {
             if(typeMap == null)
@@ -107,15 +96,12 @@ private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types,
                     return;
                 }
                 typeMapsChecked.Add(typeMap);
-
                 var context = new ValidationContext(types, memberMap, typeMap);
                 Validate(context);
-
                 if(!typeMap.ShouldCheckForValid)
                 {
                     return;
                 }
-
                 CheckPropertyMaps(typeMapsChecked, typeMap);
             }
             else
@@ -133,7 +119,6 @@ private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types,
                 }
             }
         }
-
         private void CheckPropertyMaps(ICollection<TypeMap> typeMapsChecked, TypeMap typeMap)
         {
             foreach (var memberMap in typeMap.MemberMaps)

src/AutoMapper/Configuration/Conventions/Mappers.cs

@@ -36,8 +36,6 @@ public MemberInfo GetMatchingMemberInfo(TypeDetails sourceTypeDetails, Type dest
     }
     public class PrePostfixName : ISourceToDestinationNameMapper
     {
-        public List<string> Prefixes { get; } = new();
-        public List<string> Postfixes { get; } = new();
         public List<string> DestinationPrefixes { get; } = new();
         public List<string> DestinationPostfixes { get; } = new();
         public MemberInfo GetMatchingMemberInfo(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch)

src/AutoMapper/Configuration/Conventions/MemberConfiguration.cs

@@ -77,8 +77,8 @@ public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourc
     public class NameSplitMember : IChildMemberConfiguration
     {
         bool _default = true;
-        public INamingConvention SourceMemberNamingConvention { get; set; }
-        public INamingConvention DestinationMemberNamingConvention { get; set; }
+        public INamingConvention SourceMemberNamingConvention { get; set; } = PascalCaseNamingConvention.Instance;
+        public INamingConvention DestinationMemberNamingConvention { get; set; } = PascalCaseNamingConvention.Instance;
         public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, List<MemberInfo> resolvers, IMemberConfiguration parent, bool isReverseMap) =>
             _default ?
                 Default(options, sourceType, destType, destMemberType, nameToSearch, resolvers, parent, isReverseMap) :
@@ -143,26 +143,7 @@ bool Conventions(ProfileMap options, TypeDetails sourceType, Type destType, Type
             }
             return false;
         }
-        internal void Set(INamingConvention source, INamingConvention destination)
-        {
-            if (source == null)
-            {
-                SourceMemberNamingConvention = PascalCaseNamingConvention.Instance;
-            }
-            else
-            {
-                SourceMemberNamingConvention = source;
-                _default = false;
-            }
-            if (destination == null)
-            {
-                DestinationMemberNamingConvention = PascalCaseNamingConvention.Instance;
-            }
-            else
-            {
-                DestinationMemberNamingConvention = destination;
-                _default = false;
-            }
-        }
+        internal void Seal() => _default =  SourceMemberNamingConvention == PascalCaseNamingConvention.Instance && 
+            DestinationMemberNamingConvention == PascalCaseNamingConvention.Instance;
     }
 }

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -64,7 +64,7 @@ public class MapperConfiguration : IGlobalConfiguration
         private readonly HashSet<TypeMap> _typeMapsPath = new();
         private readonly List<MemberInfo> _sourceMembers = new();
         private readonly List<ParameterExpression> _variables = new();
-        private readonly ParameterExpression[] _parameters = new ParameterExpression[] { null, null, ContextParameter };
+        private readonly ParameterExpression[] _parameters = new[] { null, null, ContextParameter };
         private readonly CatchBlock[] _catches = new CatchBlock[1];
         private readonly List<Expression> _expressions = new();
         private readonly Dictionary<Type, DefaultExpression> _defaults;
@@ -165,9 +165,12 @@ Delegate CompileExecutionPlan(MapRequest mapRequest)
                 return executionPlan.Compile(); // breakpoint here to inspect all execution plans
             }
         }
-        public MapperConfiguration(Action<IMapperConfigurationExpression> configure)
-            : this(Build(configure))
+        public MapperConfiguration(Action<IMapperConfigurationExpression> configure) : this(Build(configure)){}
+        static MapperConfigurationExpression Build(Action<IMapperConfigurationExpression> configure)
         {
+            MapperConfigurationExpression expr = new();
+            configure(expr);
+            return expr;
         }
         public void AssertConfigurationIsValid() => _validator.AssertConfigurationExpressionIsValid(_configuredMaps.Values);
         public IMapper CreateMapper() => new Mapper(this);
@@ -242,12 +245,6 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec
                 return Lambda(fullExpression, source, destination, ContextParameter);
             }
         }
-        static MapperConfigurationExpression Build(Action<IMapperConfigurationExpression> configure)
-        {
-            var expr = new MapperConfigurationExpression();
-            configure(expr);
-            return expr;
-        }
         IProjectionBuilder IGlobalConfiguration.ProjectionBuilder => _projectionBuilder;
         Func<Type, object> IGlobalConfiguration.ServiceCtor => _serviceCtor;
         bool IGlobalConfiguration.EnableNullPropagationForQueryMapping => _enableNullPropagationForQueryMapping;

src/AutoMapper/Configuration/MapperConfigurationExpression.cs

@@ -93,8 +93,8 @@ public interface IMapperConfigurationExpression : IProfileExpression
     }
     public class MapperConfigurationExpression : Profile, IGlobalConfigurationExpression
     {
-        private readonly List<Profile> _profiles = new List<Profile>();
-        private readonly List<Validator> _validators = new List<Validator>();
+        private readonly List<Profile> _profiles = new();
+        private readonly List<Validator> _validators = new();
         private readonly List<IObjectMapper> _mappers;
         private Func<Type, object> _serviceCtor = Activator.CreateInstance;
 
@@ -119,7 +119,7 @@ void IGlobalConfigurationExpression.Validator(Validator validator) =>
         /// </summary>
         int IGlobalConfigurationExpression.MaxExecutionPlanDepth { get; set; } = 1;
 
-        Validator[] IGlobalConfigurationExpression.GetValidators() => _validators.ToArray();
+        List<Validator> IGlobalConfigurationExpression.GetValidators() => _validators;
 
         List<IProjectionMapper> IGlobalConfigurationExpression.ProjectionMappers { get; } = ProjectionBuilder.DefaultProjectionMappers();
 

src/AutoMapper/Configuration/Profile.cs

@@ -63,31 +63,28 @@ public interface IProfileConfiguration
     /// </summary>
     public abstract class Profile : IProfileExpressionInternal, IProfileConfiguration
     {
+        private readonly List<string> _prefixes = new() { "Get" };
+        private readonly List<string> _postfixes = new();
         private readonly List<TypeMapConfiguration> _typeMapConfigs = new();
         private readonly PrePostfixName _prePostfixName = new();
-        private readonly List<IMemberConfiguration> _memberConfigurations = new();
+        private readonly NameSplitMember _nameSplitMember = new();
+        private readonly List<IMemberConfiguration> _memberConfigurations;
         private List<Action<PropertyMap, IMemberConfigurationExpression>> _allPropertyMapActions;
         private List<Action<TypeMap, IMappingExpression>> _allTypeMapActions;
         private List<string> _globalIgnores;
         private List<TypeMapConfiguration> _openTypeMapConfigs;
         private List<MethodInfo> _sourceExtensionMethods;
         private List<ValueTransformerConfiguration> _valueTransformerConfigs;
         private bool? _constructorMappingEnabled;
-
         protected Profile(string profileName) : this() => ProfileName = profileName;
-
         protected Profile()
         {
             ProfileName = GetType().FullName;
-            var memberConfiguration = new MemberConfiguration();
-            memberConfiguration.MemberMappers.Add(new NameSplitMember());
-            _prePostfixName.Prefixes.Add("Get");
+            MemberConfiguration memberConfiguration = new() { MemberMappers = { _nameSplitMember } };
             memberConfiguration.NameMapper.NamedMappers.Add(_prePostfixName);
-            _memberConfigurations.Add(memberConfiguration);
+            _memberConfigurations = new() { memberConfiguration };
         }
-        protected Profile(string profileName, Action<IProfileExpression> configurationAction)
-            : this(profileName)  => configurationAction(this);
-
+        protected Profile(string profileName, Action<IProfileExpression> configurationAction) : this(profileName)  => configurationAction(this);
         IMemberConfiguration DefaultMemberConfig => _memberConfigurations[0];
         IMemberConfiguration IProfileExpressionInternal.DefaultMemberConfig => DefaultMemberConfig;
         bool? IProfileConfiguration.ConstructorMappingEnabled => _constructorMappingEnabled;
@@ -114,10 +111,20 @@ IReadOnlyCollection<Action<PropertyMap, IMemberConfigurationExpression>> IProfil
         public Func<FieldInfo, bool> ShouldMapField { get; set; }
         public Func<MethodInfo, bool> ShouldMapMethod { get; set; }
         public Func<ConstructorInfo, bool> ShouldUseConstructor { get; set; }
-        public INamingConvention SourceMemberNamingConvention { get; set; }
-        public INamingConvention DestinationMemberNamingConvention { get; set; }
+        public INamingConvention SourceMemberNamingConvention
+        {
+            get => _nameSplitMember.SourceMemberNamingConvention;
+            set => _nameSplitMember.SourceMemberNamingConvention = value;
+        }
+        public INamingConvention DestinationMemberNamingConvention
+        {
+            get => _nameSplitMember.DestinationMemberNamingConvention;
+            set => _nameSplitMember.DestinationMemberNamingConvention = value;
+        }
         public List<ValueTransformerConfiguration> ValueTransformers => _valueTransformerConfigs ??= new();
-
+        NameSplitMember IProfileExpressionInternal.NameSplitMember => _nameSplitMember;
+        List<string> IProfileExpressionInternal.Prefixes => _prefixes;
+        List<string> IProfileExpressionInternal.Postfixes => _postfixes;
         public void DisableConstructorMapping() => _constructorMappingEnabled = false;
 
         void IProfileExpressionInternal.ForAllMaps(Action<TypeMap, IMappingExpression> configuration)
@@ -164,11 +171,11 @@ public IMappingExpression CreateMap(Type sourceType, Type destinationType, Membe
             }
             return map;
         }
-        public void ClearPrefixes() => _prePostfixName.Prefixes.Clear();
+        public void ClearPrefixes() => _prefixes.Clear();
         public void ReplaceMemberName(string original, string newValue) =>
             DefaultMemberConfig.AddName<ReplaceName>(_ => _.AddReplace(original, newValue));
-        public void RecognizePrefixes(params string[] prefixes) => _prePostfixName.Prefixes.AddRange(prefixes);
-        public void RecognizePostfixes(params string[] postfixes) => _prePostfixName.Postfixes.AddRange(postfixes);
+        public void RecognizePrefixes(params string[] prefixes) => _prefixes.AddRange(prefixes);
+        public void RecognizePostfixes(params string[] postfixes) => _postfixes.AddRange(postfixes);
         public void RecognizeDestinationPrefixes(params string[] prefixes) => _prePostfixName.DestinationPrefixes.AddRange(prefixes);
         public void RecognizeDestinationPostfixes(params string[] postfixes) => _prePostfixName.DestinationPostfixes.AddRange(postfixes);
         public void AddGlobalIgnore(string propertyNameStartingWith)