cosmetic

src/AutoMapper/ApiCompatBaseline.txt

@@ -48,6 +48,7 @@ MembersMustExist : Member 'public System.Type System.Type AutoMapper.ValueTransf
 InterfacesShouldHaveSameMembers : Default interface member 'public System.Boolean AutoMapper.Configuration.IPropertyMapConfiguration.Ignored' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Default interface member 'public System.Boolean AutoMapper.Configuration.IPropertyMapConfiguration.Ignored.get()' is present in the implementation but not in the contract.
 CannotRemoveBaseTypeOrInterface : Type 'AutoMapper.Configuration.MappingExpression' does not inherit from base type 'AutoMapper.Configuration.MappingExpressionBase' in the implementation but it does in the contract.
+TypesMustExist : Type 'AutoMapper.Configuration.MappingExpression.MemberConfigurationExpression' does not exist in the implementation but it does exist in the contract.
 CannotRemoveBaseTypeOrInterface : Type 'AutoMapper.Configuration.MappingExpression<TSource, TDestination>' does not inherit from base type 'AutoMapper.Configuration.MappingExpressionBase' in the implementation but it does in the contract.
 TypesMustExist : Type 'AutoMapper.Configuration.MappingExpressionBase' does not exist in the implementation but it does exist in the contract.
 CannotRemoveBaseTypeOrInterface : Type 'AutoMapper.Configuration.MappingExpressionBase<TSource, TDestination, TMappingExpression>' does not inherit from base type 'AutoMapper.Configuration.MappingExpressionBase' in the implementation but it does in the contract.
@@ -121,4 +122,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: 122
+Total Issues: 123

src/AutoMapper/Configuration/Conventions.cs

@@ -1,5 +1,4 @@
 namespace AutoMapper.Configuration.Conventions;
-
 public interface ISourceToDestinationNameMapper
 {
     MemberInfo GetSourceMember(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch);

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -41,7 +41,7 @@ public class MapperConfiguration : IGlobalConfiguration
     private readonly Dictionary<TypePair, TypeMap> _configuredMaps;
     private readonly Dictionary<TypePair, TypeMap> _resolvedMaps;
     private readonly LockingConcurrentDictionary<TypePair, TypeMap> _runtimeMaps;
-    private ProjectionBuilder _projectionBuilder;
+    private LazyValue<ProjectionBuilder> _projectionBuilder;
     private readonly LockingConcurrentDictionary<MapRequest, Delegate> _executionPlans;
     private readonly ConfigurationValidator _validator;
     private readonly Features<IRuntimeFeature> _features = new();
@@ -74,6 +74,7 @@ public MapperConfiguration(MapperConfigurationExpression configurationExpression
         _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;
@@ -232,18 +233,8 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec
             return Lambda(fullExpression, source, destination, ContextParameter);
         }
     }
-    IProjectionBuilder IGlobalConfiguration.ProjectionBuilder
-    {
-        get
-        {
-            if (_projectionBuilder == null)
-            {
-                CreateProjectionBuilder();
-            }
-            return _projectionBuilder;
-            void CreateProjectionBuilder() => Interlocked.CompareExchange(ref _projectionBuilder, new(this, _validator.Expression.ProjectionMappers.ToArray()), null);
-        }
-    }
+    ProjectionBuilder CreateProjectionBuilder() => new(this, _validator.Expression.ProjectionMappers.ToArray());
+    IProjectionBuilder IGlobalConfiguration.ProjectionBuilder => _projectionBuilder.Value;
     Func<Type, object> IGlobalConfiguration.ServiceCtor => _serviceCtor;
     bool IGlobalConfiguration.EnableNullPropagationForQueryMapping => _enableNullPropagationForQueryMapping;
     int IGlobalConfiguration.MaxExecutionPlanDepth => _maxExecutionPlanDepth;
@@ -493,7 +484,7 @@ IObjectMapper FindMapper(TypePair types)
     void IGlobalConfiguration.AssertConfigurationIsValid(TypeMap typeMap) => _validator.AssertConfigurationIsValid(this, new[] { typeMap });
     void IGlobalConfiguration.AssertConfigurationIsValid(string profileName)
     {
-        if (Profiles.All(x => x.Name != profileName))
+        if (Array.TrueForAll(Profiles, x => x.Name != profileName))
         {
             throw new ArgumentOutOfRangeException(nameof(profileName), $"Cannot find any profiles with the name '{profileName}'.");
         }
@@ -502,4 +493,11 @@ void IGlobalConfiguration.AssertConfigurationIsValid(string profileName)
     void IGlobalConfiguration.AssertConfigurationIsValid<TProfile>() => this.Internal().AssertConfigurationIsValid(typeof(TProfile).FullName);
     void IGlobalConfiguration.RegisterAsMap(TypeMapConfiguration typeMapConfiguration) =>
         _resolvedMaps[typeMapConfiguration.Types] = GetIncludedTypeMap(new(typeMapConfiguration.SourceType, typeMapConfiguration.DestinationTypeOverride));
+}
+struct LazyValue<T> where T : class
+{
+    readonly Func<T> _factory;
+    T _value = null;
+    public T Value => LazyInitializer.EnsureInitialized(ref _value, _factory);
+    public LazyValue(Func<T> factory) => _factory = factory;
 }

src/AutoMapper/Configuration/MappingExpression.cs

@@ -52,33 +52,6 @@ internal MemberConfigurationExpression ForMember(MemberInfo destinationProperty,
         memberOptions(expression);
         return expression;
     }
-    public class MemberConfigurationExpression : MemberConfigurationExpression<object, object, object>, IMemberConfigurationExpression
-    {
-        public MemberConfigurationExpression(MemberInfo destinationMember, Type sourceType) : base(destinationMember, sourceType){}
-        public void MapFrom(Type valueResolverType) => MapFromCore(new(valueResolverType, valueResolverType.GetGenericInterface(typeof(IValueResolver<,,>))));
-        public void MapFrom(Type valueResolverType, string sourceMemberName) =>
-             MapFromCore(new(valueResolverType, valueResolverType.GetGenericInterface(typeof(IMemberValueResolver<,,,>)))
-            {
-                SourceMemberName = sourceMemberName
-            });
-        public void MapFrom<TSource, TDestination, TSourceMember, TDestMember>(IMemberValueResolver<TSource, TDestination, TSourceMember, TDestMember> resolver, string sourceMemberName) =>
-            MapFromCore(new(resolver, typeof(IMemberValueResolver<TSource, TDestination, TSourceMember, TDestMember>))
-            {
-                SourceMemberName = sourceMemberName
-            });
-        public void ConvertUsing(Type valueConverterType) => ConvertUsingCore(valueConverterType);
-        public void ConvertUsing(Type valueConverterType, string sourceMemberName) => ConvertUsingCore(valueConverterType, sourceMemberName);
-        public void ConvertUsing<TSourceMember, TDestinationMember>(IValueConverter<TSourceMember, TDestinationMember> valueConverter, string sourceMemberName) =>
-            base.ConvertUsingCore(new(valueConverter, typeof(IValueConverter<TSourceMember, TDestinationMember>))
-            {
-                SourceMemberName = sourceMemberName
-            });
-        private void ConvertUsingCore(Type valueConverterType, string sourceMemberName = null) =>
-            base.ConvertUsingCore(new(valueConverterType, valueConverterType.GetGenericInterface(typeof(IValueConverter<,>)))
-            {
-                SourceMemberName = sourceMemberName
-            });
-    }
 }
 public class MappingExpression<TSource, TDestination> : MappingExpressionBase<TSource, TDestination, IMappingExpression<TSource, TDestination>>,
     IMappingExpression<TSource, TDestination>, IProjectionExpression<TSource, TDestination>

src/AutoMapper/Configuration/MemberConfigurationExpression.cs

@@ -165,4 +165,31 @@ public IPropertyMapConfiguration Reverse()
         return PathConfigurationExpression<TDestination, TSource, object>.Create(SourceExpression, GetDestinationExpression());
     }
     public void DoNotUseDestinationValue() => SetUseDestinationValue(false);
+}
+public class MemberConfigurationExpression : MemberConfigurationExpression<object, object, object>, IMemberConfigurationExpression
+{
+    public MemberConfigurationExpression(MemberInfo destinationMember, Type sourceType) : base(destinationMember, sourceType){}
+    public void MapFrom(Type valueResolverType) => MapFromCore(new(valueResolverType, valueResolverType.GetGenericInterface(typeof(IValueResolver<,,>))));
+    public void MapFrom(Type valueResolverType, string sourceMemberName) =>
+            MapFromCore(new(valueResolverType, valueResolverType.GetGenericInterface(typeof(IMemberValueResolver<,,,>)))
+        {
+            SourceMemberName = sourceMemberName
+        });
+    public void MapFrom<TSource, TDestination, TSourceMember, TDestMember>(IMemberValueResolver<TSource, TDestination, TSourceMember, TDestMember> resolver, string sourceMemberName) =>
+        MapFromCore(new(resolver, typeof(IMemberValueResolver<TSource, TDestination, TSourceMember, TDestMember>))
+        {
+            SourceMemberName = sourceMemberName
+        });
+    public void ConvertUsing(Type valueConverterType) => ConvertUsingCore(valueConverterType);
+    public void ConvertUsing(Type valueConverterType, string sourceMemberName) => ConvertUsingCore(valueConverterType, sourceMemberName);
+    public void ConvertUsing<TSourceMember, TDestinationMember>(IValueConverter<TSourceMember, TDestinationMember> valueConverter, string sourceMemberName) =>
+        base.ConvertUsingCore(new(valueConverter, typeof(IValueConverter<TSourceMember, TDestinationMember>))
+        {
+            SourceMemberName = sourceMemberName
+        });
+    private void ConvertUsingCore(Type valueConverterType, string sourceMemberName = null) =>
+        base.ConvertUsingCore(new(valueConverterType, valueConverterType.GetGenericInterface(typeof(IValueConverter<,>)))
+        {
+            SourceMemberName = sourceMemberName
+        });
 }

src/AutoMapper/Features.cs

@@ -1,5 +1,4 @@
-using System.Collections;
-namespace AutoMapper.Features;
+namespace AutoMapper.Features;
 public interface IGlobalFeature
 {
     void Configure(IGlobalConfiguration configuration);

src/AutoMapper/ProfileMap.cs

@@ -9,7 +9,7 @@ public class ProfileMap
     private TypeMapConfiguration[] _typeMapConfigs;
     private Dictionary<TypePair, TypeMapConfiguration> _openTypeMapConfigs;
     private Dictionary<Type, TypeDetails> _typeDetails;
-    private ConcurrentDictionary<Type, TypeDetails> _runtimeTypeDetails;
+    private LazyValue<ConcurrentDictionary<Type, TypeDetails>> _runtimeTypeDetails;
     public ProfileMap(IProfileConfiguration profile, IGlobalConfigurationExpression configuration = null)
     {
         var globalProfile = (IProfileConfiguration)configuration;
@@ -39,6 +39,7 @@ public ProfileMap(IProfileConfiguration profile, IGlobalConfigurationExpression
         TypeMapConfigs();
         OpenTypeMapConfigs();
         _typeDetails = new(2 * _typeMapConfigs.Length);
+       _runtimeTypeDetails = new(()=>new(Environment.ProcessorCount, 2 * _openTypeMapConfigs.Count));
         return;
         void TypeMapConfigs()
         {
@@ -99,7 +100,7 @@ public TypeDetails CreateTypeDetails(Type type)
     {
         if (_typeDetails == null)
         {
-            return CreateRuntimeTypeDetails(type);
+            return _runtimeTypeDetails.Value.GetOrAdd(type, (type, profile) => new(type, profile), this);
         }
         if (_typeDetails.TryGetValue(type, out var typeDetails))
         {
@@ -108,14 +109,6 @@ public TypeDetails CreateTypeDetails(Type type)
         typeDetails = new(type, this);
         _typeDetails.Add(type, typeDetails);
         return typeDetails;
-        TypeDetails CreateRuntimeTypeDetails(Type type)
-        {
-            if (_runtimeTypeDetails == null)
-            {
-                Interlocked.CompareExchange(ref _runtimeTypeDetails, new(Environment.ProcessorCount, 2 * _openTypeMapConfigs.Count), null);
-            }
-            return _runtimeTypeDetails.GetOrAdd(type, (type, profile) => new(type, profile), this);
-        }
     }
     public void Register(IGlobalConfiguration configuration)
     {
@@ -187,7 +180,7 @@ private void Configure(TypeMap typeMap, IGlobalConfiguration configuration)
         {
             foreach (var propertyMap in typeMap.PropertyMaps)
             {
-                var memberExpression = new MappingExpression.MemberConfigurationExpression(propertyMap.DestinationMember, typeMap.SourceType);
+                var memberExpression = new MemberConfigurationExpression(propertyMap.DestinationMember, typeMap.SourceType);
                 action(propertyMap, memberExpression);
                 memberExpression.Configure(typeMap);
             }

src/UnitTests/Projection/ProjectTest.cs

@@ -20,6 +20,12 @@ public class FooDto
     public void Should_work()
     {
         new[] { new Foo() }.AsQueryable().ProjectTo<FooDto>(Configuration).Single().A.ShouldBe(0);
+
+        var p1 = Configuration.Internal().ProjectionBuilder;
+        var p2 = Configuration.Internal().ProjectionBuilder;
+        p2.ShouldBe(p1);
+        var profile = Configuration.Internal().Profiles[0];
+        profile.CreateTypeDetails(typeof(DateTime)).ShouldBe(profile.CreateTypeDetails(typeof(DateTime)));
     } 
 }