simplify

Author: lbargaoanu

src/AutoMapper/ApiCompatBaseline.txt

@@ -23,6 +23,9 @@ CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttri
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttribute' exists on generic param 'TDestination' on member 'AutoMapper.IMapper.ProjectTo<TDestination>(System.Linq.IQueryable, System.Object, System.Linq.Expressions.Expression<System.Func<TDestination, System.Object>>[])' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableContextAttribute' exists on 'AutoMapper.IMapperBase' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttribute' exists on parameter 'destinationType' on member 'AutoMapper.IMapperBase.Map(System.Object, System.Type, System.Type)' in the contract but not the implementation.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Action<AutoMapper.TypeMap, AutoMapper.IMappingExpression> AutoMapper.IProfileConfiguration.AllTypeMapActions.get()' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<System.Action<AutoMapper.TypeMap, AutoMapper.IMappingExpression>> AutoMapper.IProfileConfiguration.AllTypeMapActions.get()' is present in the contract but not in the implementation.
+MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<System.Action<AutoMapper.TypeMap, AutoMapper.IMappingExpression>> AutoMapper.IProfileConfiguration.AllTypeMapActions.get()' does not exist in the implementation but it does exist in the contract.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttribute' exists on generic param 'TDestination' on member 'AutoMapper.ResolutionContext.AutoMapper.IMapperBase.Map<TDestination>(System.Object)' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttribute' exists on generic param 'TSource' on member 'AutoMapper.ResolutionContext.AutoMapper.IMapperBase.Map<TSource, TDestination>(TSource)' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttribute' exists on generic param 'TDestination' on member 'AutoMapper.ResolutionContext.AutoMapper.IMapperBase.Map<TSource, TDestination>(TSource)' in the contract but not the implementation.
@@ -31,6 +34,7 @@ CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttri
 MembersMustExist : Member 'public void AutoMapper.Configuration.MappingExpression..ctor(AutoMapper.Internal.TypePair, AutoMapper.MemberList)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public void AutoMapper.Configuration.MappingExpression<TSource, TDestination>..ctor(AutoMapper.MemberList, System.Type, System.Type)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'protected void AutoMapper.Configuration.MappingExpressionBase<TSource, TDestination, TMappingExpression>..ctor(AutoMapper.MemberList, System.Type, System.Type)' does not exist in the implementation but it does exist in the contract.
+MembersMustExist : Member 'protected System.Collections.Generic.List<System.Action<AutoMapper.PropertyMap>> AutoMapper.Configuration.MemberConfigurationExpression<TSource, TDestination, TMember>.PropertyMapActions.get()' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public void AutoMapper.Configuration.ValidationContext..ctor(AutoMapper.Internal.TypePair, AutoMapper.MemberMap, AutoMapper.TypeMap, AutoMapper.Internal.Mappers.IObjectMapper)' does not exist in the implementation but it does exist in the contract.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.IgnoreAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.MapAtRuntimeAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
@@ -70,4 +74,4 @@ CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttri
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableContextAttribute' exists on 'AutoMapper.QueryableExtensions.Extensions.ProjectTo<TDestination>(System.Linq.IQueryable, AutoMapper.IConfigurationProvider, System.Object, System.Linq.Expressions.Expression<System.Func<TDestination, System.Object>>[])' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttribute' exists on parameter 'parameters' on member 'AutoMapper.QueryableExtensions.Extensions.ProjectTo<TDestination>(System.Linq.IQueryable, AutoMapper.IConfigurationProvider, System.Object, System.Linq.Expressions.Expression<System.Func<TDestination, System.Object>>[])' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'System.Runtime.CompilerServices.NullableAttribute' exists on generic param 'TDestination' on member 'AutoMapper.QueryableExtensions.Extensions.ProjectTo<TDestination>(System.Linq.IQueryable, AutoMapper.IConfigurationProvider, System.Object, System.Linq.Expressions.Expression<System.Func<TDestination, System.Object>>[])' in the contract but not the implementation.
-Total Issues: 71
+Total Issues: 75

src/AutoMapper/Configuration/CtorParamConfigurationExpression.cs

@@ -38,20 +38,20 @@ public sealed class CtorParamConfigurationExpression<TSource, TDestination>(stri
 {
     public string CtorParamName { get; } = ctorParamName;
     public Type SourceType { get; } = sourceType;
-    private readonly List<Action<ConstructorParameterMap>> _ctorParamActions = [];
+    private Action<ConstructorParameterMap> _ctorParamActions;
     public void MapFrom<TMember>(Expression<Func<TSource, TMember>> sourceMember) =>
-        _ctorParamActions.Add(cpm => cpm.MapFrom(sourceMember));
+        _ctorParamActions += cpm => cpm.MapFrom(sourceMember);
     public void MapFrom<TMember>(Func<TSource, ResolutionContext, TMember> resolver)
     {
         Expression<Func<TSource, TDestination, TMember, ResolutionContext, TMember>> resolverExpression = (src, dest, destMember, ctxt) => resolver(src, ctxt);
-        _ctorParamActions.Add(cpm => cpm.SetResolver(new FuncResolver(resolverExpression)));
+        _ctorParamActions += cpm => cpm.SetResolver(new FuncResolver(resolverExpression));
     }
     public void MapFrom(string sourceMembersPath)
     {
         var sourceMembers = ReflectionHelper.GetMemberPath(SourceType, sourceMembersPath);
-        _ctorParamActions.Add(cpm => cpm.MapFrom(sourceMembersPath, sourceMembers));
+        _ctorParamActions += cpm => cpm.MapFrom(sourceMembersPath, sourceMembers);
     }
-    public void ExplicitExpansion(bool value) => _ctorParamActions.Add(cpm => cpm.ExplicitExpansion = value);
+    public void ExplicitExpansion(bool value) => _ctorParamActions += cpm => cpm.ExplicitExpansion = value;
     public void Configure(TypeMap typeMap)
     {
         var ctorMap = typeMap.ConstructorMap;
@@ -64,9 +64,6 @@ public void Configure(TypeMap typeMap)
         {
             throw new AutoMapperConfigurationException($"{typeMap.DestinationType.Name} does not have a matching constructor with a parameter named '{CtorParamName}'.\n{typeMap.DestinationType.FullName}.{typeMap.CheckRecord()}");
         }
-        foreach (var action in _ctorParamActions)
-        {
-            action(parameter);
-        }
+        _ctorParamActions?.Invoke(parameter);
     }
 }

src/AutoMapper/Configuration/MappingExpression.cs

@@ -21,18 +21,18 @@ public IMappingExpression IncludeMembers(params string[] memberNames)
         {
             SourceType.GetFieldOrProperty(memberName);
         }
-        TypeMapActions.Add(tm => tm.IncludedMembersNames = memberNames);
+        TypeMapActions += tm => tm.IncludedMembersNames = memberNames;
         return this;
     }
     public void ForAllMembers(Action<IMemberConfigurationExpression> memberOptions)
     {
-        TypeMapActions.Add(typeMap =>
+        TypeMapActions += typeMap =>
         {
             foreach (var accessor in typeMap.DestinationSetters)
             {
                 ForMember(accessor, memberOptions);
             }
-        });
+        };
     }
     public IMappingExpression ForMember(string name, Action<IMemberConfigurationExpression> memberOptions)
     {
@@ -77,7 +77,7 @@ public IMappingExpression<TSource, TDestination> ForMember<TMember>(Expression<F
         var memberInfo = ReflectionHelper.FindProperty(destinationMember);
         return ForDestinationMember(memberInfo, memberOptions);
     }
-    private void IncludeMembersCore(LambdaExpression[] memberExpressions) => TypeMapActions.Add(tm => tm.IncludedMembers = memberExpressions);
+    private void IncludeMembersCore(LambdaExpression[] memberExpressions) => TypeMapActions += tm => tm.IncludedMembers = memberExpressions;
     public IMappingExpression<TSource, TDestination> IncludeMembers(params Expression<Func<TSource, object>>[] memberExpressions)
     {
         var memberExpressionsWithoutCastToObject = Array.ConvertAll(
@@ -97,13 +97,13 @@ public IMappingExpression<TSource, TDestination> ForMember(string name, Action<I
     }
     public void ForAllMembers(Action<IMemberConfigurationExpression<TSource, TDestination, object>> memberOptions)
     {
-        TypeMapActions.Add(typeMap =>
+        TypeMapActions += typeMap =>
         {
             foreach (var accessor in typeMap.DestinationSetters)
             {
                 ForDestinationMember(accessor, memberOptions);
             }
-        });
+        };
     }
     public IMappingExpression<TSource, TDestination> Include<TOtherSource, TOtherDestination>() where TOtherSource : TSource where TOtherDestination : TDestination
     {

src/AutoMapper/Configuration/MemberConfigurationExpression.cs

@@ -12,14 +12,14 @@ public class MemberConfigurationExpression<TSource, TDestination, TMember>(Membe
 {
     private MemberInfo[] _sourceMembers;
     private readonly Type _sourceType = sourceType;
-    protected List<Action<PropertyMap>> PropertyMapActions { get; } = [];
+    protected Action<PropertyMap> PropertyMapActions { get; set; }
     public MemberInfo DestinationMember { get; } = destinationMember;
-    public void MapAtRuntime() => PropertyMapActions.Add(pm => pm.Inline = false);
-    public void NullSubstitute(object nullSubstitute) => PropertyMapActions.Add(pm => pm.NullSubstitute = nullSubstitute);
+    public void MapAtRuntime() => PropertyMapActions += pm => pm.Inline = false;
+    public void NullSubstitute(object nullSubstitute) => PropertyMapActions += pm => pm.NullSubstitute = nullSubstitute;
     public void MapFrom<TValueResolver>() where TValueResolver : IValueResolver<TSource, TDestination, TMember> =>
         MapFromCore(new(typeof(TValueResolver), typeof(IValueResolver<TSource, TDestination, TMember>)));
     protected void MapFromCore(ClassValueResolver config) => SetResolver(config);
-    protected void SetResolver(IValueResolver config) => PropertyMapActions.Add(pm => pm.SetResolver(config));
+    protected void SetResolver(IValueResolver config) => PropertyMapActions += pm => pm.SetResolver(config);
     public void MapFrom<TValueResolver, TSourceMember>(Expression<Func<TSource, TSourceMember>> sourceMember)
         where TValueResolver : IMemberValueResolver<TSource, TDestination, TSourceMember, TMember> =>
             MapFromCore<TValueResolver, TSourceMember>(sourceMember);
@@ -49,12 +49,12 @@ private void MapFromFunc<TResult>(Expression<Func<TSource, TDestination, TMember
     internal void MapFromExpression(LambdaExpression sourceExpression)
     {
         SourceExpression = sourceExpression;
-        PropertyMapActions.Add(pm => pm.MapFrom(sourceExpression));
+        PropertyMapActions += pm => pm.MapFrom(sourceExpression);
     }
     public void MapFrom(string sourceMembersPath)
     {
         _sourceMembers = ReflectionHelper.GetMemberPath(_sourceType, sourceMembersPath);
-        PropertyMapActions.Add(pm => pm.MapFrom(sourceMembersPath, _sourceMembers));
+        PropertyMapActions += pm => pm.MapFrom(sourceMembersPath, _sourceMembers);
     }
     public void Condition(Func<TSource, TDestination, TMember, TMember, ResolutionContext, bool> condition) =>
         ConditionCore((src, dest, srcMember, destMember, ctxt) => condition(src, dest, srcMember, destMember, ctxt));
@@ -65,35 +65,35 @@ public void Condition(Func<TSource, TDestination, TMember, bool> condition) =>
     public void Condition(Func<TSource, TDestination, bool> condition) => ConditionCore((src, dest, srcMember, destMember, ctxt) => condition(src, dest));
     public void Condition(Func<TSource, bool> condition) => ConditionCore((src, dest, srcMember, destMember, ctxt) => condition(src));
     private void ConditionCore(Expression<Func<TSource, TDestination, TMember, TMember, ResolutionContext, bool>> expr) =>
-        PropertyMapActions.Add(pm => pm.Condition = expr);
+        PropertyMapActions += pm => pm.Condition = expr;
     public void PreCondition(Func<TSource, bool> condition) => PreConditionCore((src, dest, ctxt) => condition(src));
     public void PreCondition(Func<ResolutionContext, bool> condition) => PreConditionCore((src, dest, ctxt) => condition(ctxt));
     public void PreCondition(Func<TSource, ResolutionContext, bool> condition) => PreConditionCore((src, dest, ctxt) => condition(src, ctxt));
     public void PreCondition(Func<TSource, TDestination, ResolutionContext, bool> condition) => PreConditionCore((src, dest, ctxt) => condition(src, dest, ctxt));
     private void PreConditionCore(Expression<Func<TSource, TDestination, ResolutionContext, bool>> expr) =>
-        PropertyMapActions.Add(pm => pm.PreCondition = expr);
+        PropertyMapActions += pm => pm.PreCondition = expr;
     public void AddTransform(Expression<Func<TMember, TMember>> transformer) =>
-        PropertyMapActions.Add(pm => pm.AddValueTransformation(new ValueTransformerConfiguration(pm.DestinationType, transformer)));
-    public void ExplicitExpansion(bool value) => PropertyMapActions.Add(pm => pm.ExplicitExpansion = value);
+        PropertyMapActions += pm => pm.AddValueTransformation(new ValueTransformerConfiguration(pm.DestinationType, transformer));
+    public void ExplicitExpansion(bool value) => PropertyMapActions += pm => pm.ExplicitExpansion = value;
     public void Ignore() => Ignore(ignorePaths: true);
     public void Ignore(bool ignorePaths)
     {
         Ignored = true;
-        PropertyMapActions.Add(pm =>
+        PropertyMapActions += pm =>
         {
             pm.Ignored = true;
             if (ignorePaths && pm.TypeMap.PathMaps.Count > 0)
             {
                 pm.TypeMap.IgnorePaths(DestinationMember);
             }
-        });
+        };
     }
     public void AllowNull() => SetAllowNull(true);
     public void DoNotAllowNull() => SetAllowNull(false);
-    private void SetAllowNull(bool value) => PropertyMapActions.Add(pm => pm.AllowNull = value);
+    private void SetAllowNull(bool value) => PropertyMapActions += pm => pm.AllowNull = value;
     public void UseDestinationValue() => SetUseDestinationValue(true);
-    private void SetUseDestinationValue(bool value) => PropertyMapActions.Add(pm => pm.UseDestinationValue = value);
-    public void SetMappingOrder(int mappingOrder) => PropertyMapActions.Add(pm => pm.MappingOrder = mappingOrder);
+    private void SetUseDestinationValue(bool value) => PropertyMapActions += pm => pm.UseDestinationValue = value;
+    public void SetMappingOrder(int mappingOrder) => PropertyMapActions += pm => pm.MappingOrder = mappingOrder;
     public void ConvertUsing<TValueConverter, TSourceMember>() where TValueConverter : IValueConverter<TSourceMember, TMember> => 
         ConvertUsingCore<TValueConverter, TSourceMember>();
     public void ConvertUsing<TValueConverter, TSourceMember>(Expression<Func<TSource, TSourceMember>> sourceMember) where TValueConverter : IValueConverter<TSourceMember, TMember> => 
@@ -127,13 +127,7 @@ public void Configure(TypeMap typeMap)
         var propertyMap = typeMap.FindOrCreatePropertyMapFor(destMember, typeof(TMember) == typeof(object) ? destMember.GetMemberType() : typeof(TMember));
         Apply(propertyMap);
     }
-    private void Apply(PropertyMap propertyMap)
-    {
-        foreach(var action in PropertyMapActions)
-        {
-            action(propertyMap);
-        }
-    }
+    private void Apply(PropertyMap propertyMap) => PropertyMapActions?.Invoke(propertyMap);
     public LambdaExpression SourceExpression { get; private set; }
     public bool Ignored { get; private set; }
     public LambdaExpression GetDestinationExpression() => DestinationMember.Lambda();

src/AutoMapper/Configuration/PathConfigurationExpression.cs

@@ -25,28 +25,22 @@ public sealed class PathConfigurationExpression<TSource, TDestination, TMember>(
 {
     private readonly LambdaExpression _destinationExpression = destinationExpression;
     private LambdaExpression _sourceExpression;
-    List<Action<PathMap>> PathMapActions { get; } = [];
+    Action<PathMap> PathMapActions { get; set; }
     public MemberPath MemberPath { get; } = new(chain);
     public MemberInfo DestinationMember => MemberPath.Last;
     public void MapFrom<TSourceMember>(Expression<Func<TSource, TSourceMember>> sourceExpression) => MapFromUntyped(sourceExpression);
-    public void Ignore() => PathMapActions.Add(pm => pm.Ignored = true);
+    public void Ignore() => PathMapActions += pm => pm.Ignored = true;
     public void MapFromUntyped(LambdaExpression sourceExpression)
     {
         _sourceExpression = sourceExpression ?? throw new ArgumentNullException(nameof(sourceExpression), $"{nameof(sourceExpression)} may not be null when mapping {DestinationMember.Name} from {typeof(TSource)} to {typeof(TDestination)}.");
-        PathMapActions.Add(pm => pm.MapFrom(sourceExpression));
+        PathMapActions += pm => pm.MapFrom(sourceExpression);
     }
     public void Configure(TypeMap typeMap)
     {
         var pathMap = typeMap.FindOrCreatePathMapFor(_destinationExpression, MemberPath, typeMap);
         Apply(pathMap);
     }
-    private void Apply(PathMap pathMap)
-    {
-        foreach (var action in PathMapActions)
-        {
-            action(pathMap);
-        }
-    }
+    private void Apply(PathMap pathMap) => PathMapActions?.Invoke(pathMap);
     internal static IPropertyMapConfiguration Create(LambdaExpression destination, LambdaExpression source)
     {
         if (destination == null || !destination.IsMemberPath(out var chain))
@@ -67,10 +61,10 @@ internal static IPropertyMapConfiguration Create(LambdaExpression destination, L
     public LambdaExpression GetDestinationExpression() => _destinationExpression;
     public IPropertyMapConfiguration Reverse() => Create(_sourceExpression, _destinationExpression);
     public void Condition(Func<ConditionParameters<TSource, TDestination, TMember>, bool> condition) =>
-        PathMapActions.Add(pm =>
+        PathMapActions += pm =>
         {
             Expression<Func<TSource, TDestination, TMember, TMember, ResolutionContext, bool>> expr =
                 (src, dest, srcMember, destMember, ctxt) => condition(new(src, dest, srcMember, destMember, ctxt));
             pm.Condition = expr;
-        });
+        };
 }