cosmetic

Author: lbargaoanu

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -45,10 +45,6 @@ public class MapperConfiguration : IGlobalConfiguration
     private readonly LockingConcurrentDictionary<MapRequest, Delegate> _executionPlans;
     private readonly ConfigurationValidator _validator;
     private readonly Features<IRuntimeFeature> _features = new();
-    private readonly int _recursiveQueriesMaxDepth;
-    private readonly int _maxExecutionPlanDepth;
-    private readonly bool _enableNullPropagationForQueryMapping;
-    private readonly Func<Type, object> _serviceCtor;
     private readonly bool _sealed;
     private readonly bool _hasOpenMaps;
     private readonly HashSet<TypeMap> _typeMapsPath = new();
@@ -71,11 +67,7 @@ public MapperConfiguration(MapperConfigurationExpression configurationExpression
         _mappers = configuration.Mappers.ToArray();
         _executionPlans = new(CompileExecutionPlan);
         _validator = new(configuration);
-        _serviceCtor = configuration.ServiceCtor;
-        _enableNullPropagationForQueryMapping = configuration.EnableNullPropagationForQueryMapping ?? false;
-        _maxExecutionPlanDepth = configuration.MaxExecutionPlanDepth + 1;
         _projectionBuilder = new(CreateProjectionBuilder);
-        _recursiveQueriesMaxDepth = configuration.RecursiveQueriesMaxDepth;
         Configuration = new((IProfileConfiguration)configuration);
         int typeMapsCount = Configuration.TypeMapsCount;
         int openTypeMapsCount = Configuration.OpenTypeMapsCount;
@@ -233,15 +225,16 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec
             return Lambda(fullExpression, source, destination, ContextParameter);
         }
     }
-    ProjectionBuilder CreateProjectionBuilder() => new(this, _validator.Expression.ProjectionMappers.ToArray());
+    IGlobalConfigurationExpression ConfigurationExpression => _validator.Expression;
+    ProjectionBuilder CreateProjectionBuilder() => new(this, ConfigurationExpression.ProjectionMappers.ToArray());
     IProjectionBuilder IGlobalConfiguration.ProjectionBuilder => _projectionBuilder.Value;
-    Func<Type, object> IGlobalConfiguration.ServiceCtor => _serviceCtor;
-    bool IGlobalConfiguration.EnableNullPropagationForQueryMapping => _enableNullPropagationForQueryMapping;
-    int IGlobalConfiguration.MaxExecutionPlanDepth => _maxExecutionPlanDepth;
+    Func<Type, object> IGlobalConfiguration.ServiceCtor => ConfigurationExpression.ServiceCtor;
+    bool IGlobalConfiguration.EnableNullPropagationForQueryMapping => ConfigurationExpression.EnableNullPropagationForQueryMapping.GetValueOrDefault();
+    int IGlobalConfiguration.MaxExecutionPlanDepth => ConfigurationExpression.MaxExecutionPlanDepth + 1;
     private ProfileMap Configuration { get; }
     ProfileMap[] IGlobalConfiguration.Profiles => Profiles;
     internal ProfileMap[] Profiles { get; }
-    int IGlobalConfiguration.RecursiveQueriesMaxDepth => _recursiveQueriesMaxDepth;
+    int IGlobalConfiguration.RecursiveQueriesMaxDepth => ConfigurationExpression.RecursiveQueriesMaxDepth;
     Features<IRuntimeFeature> IGlobalConfiguration.Features => _features;
     List<MemberInfo> IGlobalConfiguration.SourceMembers => _sourceMembers;
     List<ParameterExpression> IGlobalConfiguration.Variables => _variables;

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -449,5 +449,5 @@ public class ParameterReplaceVisitor : ReplaceVisitorBase
 public class ConvertParameterReplaceVisitor : ParameterReplaceVisitor
 {
     public override Expression Replace(Expression target, Expression oldNode, Expression newNode) => 
-        base.Replace(target, oldNode, ExpressionBuilder.ToType(newNode, oldNode.Type));
+        base.Replace(target, oldNode, ToType(newNode, oldNode.Type));
 }

src/AutoMapper/Internal/TypeDetails.cs

@@ -93,15 +93,15 @@ class GenericMethod : MemberInfo
     {
         readonly MethodInfo _genericMethod;
         readonly Type _genericInterface;
-        MethodInfo _closedMethod = ExpressionBuilder.DecTypeDepthInfo;
+        MethodInfo _closedMethod = DecTypeDepthInfo;
         public GenericMethod(MethodInfo genericMethod, Type genericInterface)
         {
             _genericMethod = genericMethod;
             _genericInterface = genericInterface;
         }
         public MethodInfo Close()
         {
-            if (_closedMethod == ExpressionBuilder.DecTypeDepthInfo)
+            if (_closedMethod == DecTypeDepthInfo)
             {
                 // Use method.MakeGenericMethod(genericArguments) wrapped in a try/catch(ArgumentException)
                 // in order to catch exceptions resulting from the generic arguments not being compatible

src/AutoMapper/Mappers/ToStringMapper.cs

@@ -5,7 +5,7 @@ public class ToStringMapper : IObjectMapper
     public Expression MapExpression(IGlobalConfiguration configuration, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
     {
         var sourceType = sourceExpression.Type;
-        var toStringCall = Call(sourceExpression, ExpressionBuilder.ObjectToString);
+        var toStringCall = Call(sourceExpression, ObjectToString);
         return sourceType.IsEnum ? StringToEnumMapper.CheckEnumMember(sourceExpression, sourceType, toStringCall) : toStringCall;
     }
 }

src/AutoMapper/QueryableExtensions/ProjectionMappers/AssignableProjectionMapper.cs

@@ -1,9 +1,8 @@
 namespace AutoMapper.QueryableExtensions.Impl;
-
 [EditorBrowsable(EditorBrowsableState.Never)]
 public class AssignableProjectionMapper : IProjectionMapper
 {
     public bool IsMatch(TypePair context) => context.DestinationType.IsAssignableFrom(context.SourceType);
     public Expression Project(IGlobalConfiguration configuration, in ProjectionRequest request, Expression resolvedSource, LetPropertyMaps letPropertyMaps)
-        => ExpressionBuilder.ToType(resolvedSource, request.DestinationType);
+        => ToType(resolvedSource, request.DestinationType);
 }

src/AutoMapper/QueryableExtensions/ProjectionMappers/StringProjectionMapper.cs

@@ -5,5 +5,5 @@ public class StringProjectionMapper : IProjectionMapper
 {
     public bool IsMatch(TypePair context) => context.DestinationType == typeof(string);
     public Expression Project(IGlobalConfiguration configuration, in ProjectionRequest request, Expression resolvedSource, LetPropertyMaps letPropertyMaps)
-        => Expression.Call(resolvedSource, ExpressionBuilder.ObjectToString);
+        => Expression.Call(resolvedSource, ObjectToString);
 }