don't throw and catch on validation

lbargaoanu · lbargaoanu · commit a384948f40d4 · 2025-02-08T21:35:23.000+02:00
diff --git a/.editorconfig b/.editorconfig
@@ -6,6 +6,8 @@ end_of_line = lf
 indent_style = space
 indent_size = 4
 
+csharp_space_around_binary_operators = before_and_after
+
 #### Naming styles ####
 
 # Constants are PascalCase
diff --git a/src/AutoMapper/ApiCompatBaseline.txt b/src/AutoMapper/ApiCompatBaseline.txt
@@ -31,6 +31,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 '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.
 CannotChangeAttribute : Attribute 'System.AttributeUsageAttribute' on 'AutoMapper.Configuration.Annotations.MappingOrderAttribute' changed from '[AttributeUsageAttribute(384)]' in the contract to '[AttributeUsageAttribute(AttributeTargets.Field | AttributeTargets.Property)]' in the implementation.
@@ -69,4 +70,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: 70
+Total Issues: 71
diff --git a/src/AutoMapper/Configuration/ConfigurationValidator.cs b/src/AutoMapper/Configuration/ConfigurationValidator.cs
@@ -1,120 +1,116 @@
 using AutoMapper.Internal.Mappers;
 namespace AutoMapper.Configuration;
 [EditorBrowsable(EditorBrowsableState.Never)]
-public readonly record struct ConfigurationValidator(IGlobalConfigurationExpression Expression)
+public class ConfigurationValidator(IGlobalConfiguration config)
 {
-    private void Validate(ValidationContext context)
-    {
-        foreach (var validator in Expression.Validators)
-        {
-            validator(context);
-        }
-    }
-    public void AssertConfigurationExpressionIsValid(IGlobalConfiguration config, TypeMap[] typeMaps)
+    IGlobalConfigurationExpression Expression => ((MapperConfiguration)config).ConfigurationExpression;
+    public void AssertConfigurationExpressionIsValid(TypeMap[] typeMaps)
     {
         var duplicateTypeMapConfigs = Expression.Profiles.Append((Profile)Expression)
             .SelectMany(p => p.TypeMapConfigs, (profile, typeMap) => (profile, typeMap))
             .GroupBy(x => x.typeMap.Types)
             .Where(g => g.Count() > 1)
-            .Select(g => (TypePair : g.Key, ProfileNames : g.Select(tmc => tmc.profile.ProfileName).ToArray()))
+            .Select(g => (TypePair: g.Key, ProfileNames: g.Select(tmc => tmc.profile.ProfileName).ToArray()))
             .Select(g => new DuplicateTypeMapConfigurationException.TypeMapConfigErrors(g.TypePair, g.ProfileNames))
             .ToArray();
-        if (duplicateTypeMapConfigs.Any())
+        if(duplicateTypeMapConfigs.Length != 0)
         {
             throw new DuplicateTypeMapConfigurationException(duplicateTypeMapConfigs);
         }
-        AssertConfigurationIsValid(config, typeMaps);
+        AssertConfigurationIsValid(typeMaps);
     }
-    public void AssertConfigurationIsValid(IGlobalConfiguration config, TypeMap[] typeMaps)
+    public void AssertConfigurationIsValid(TypeMap[] typeMaps)
     {
+        List<Exception> configExceptions = [];
         var badTypeMaps =
             (from typeMap in typeMaps
-                where typeMap.ShouldCheckForValid
-                let unmappedPropertyNames = typeMap.GetUnmappedPropertyNames()
-                let canConstruct = typeMap.PassesCtorValidation
-                where unmappedPropertyNames.Length > 0 || !canConstruct
-                select new AutoMapperConfigurationException.TypeMapConfigErrors(typeMap, unmappedPropertyNames, canConstruct)
-                ).ToArray();
-        if (badTypeMaps.Length > 0)
+             where typeMap.ShouldCheckForValid
+             let unmappedPropertyNames = typeMap.GetUnmappedPropertyNames()
+             let canConstruct = typeMap.PassesCtorValidation
+             where unmappedPropertyNames.Length > 0 || !canConstruct
+             select new AutoMapperConfigurationException.TypeMapConfigErrors(typeMap, unmappedPropertyNames, canConstruct)).ToArray();
+        if(badTypeMaps.Length > 0)
         {
-            throw new AutoMapperConfigurationException(badTypeMaps);
+            configExceptions.Add(new AutoMapperConfigurationException(badTypeMaps));
         }
         HashSet<TypeMap> typeMapsChecked = [];
-        List<Exception> configExceptions = [];
-        foreach (var typeMap in typeMaps)
+        foreach(var typeMap in typeMaps)
         {
-            try
-            {
-                DryRunTypeMap(config, typeMapsChecked, typeMap.Types, typeMap, null);
-            }
-            catch (Exception e)
-            {
-                configExceptions.Add(e);
-            }
+            DryRunTypeMap(typeMap.Types, typeMap, null);
         }
-        if (configExceptions.Count > 1)
+        if(configExceptions.Count > 1)
         {
             throw new AggregateException(configExceptions);
         }
-        if (configExceptions.Count > 0)
+        if(configExceptions.Count > 0)
         {
             throw configExceptions[0];
         }
-    }
-    private void DryRunTypeMap(IGlobalConfiguration config, HashSet<TypeMap> typeMapsChecked, TypePair types, TypeMap typeMap, MemberMap memberMap)
-    {
-        if(typeMap == null)
+        void DryRunTypeMap(TypePair types, TypeMap typeMap, MemberMap memberMap)
         {
-            if (types.ContainsGenericParameters)
+            if(typeMap == null)
             {
-                return;
+                if(types.ContainsGenericParameters)
+                {
+                    return;
+                }
+                typeMap = config.ResolveTypeMap(types.SourceType, types.DestinationType);
             }
-            typeMap = config.ResolveTypeMap(types.SourceType, types.DestinationType);
-        }
-        if (typeMap != null)
-        {
-            if (typeMapsChecked.Contains(typeMap))
+            if(typeMap != null)
             {
-                return;
+                if(typeMapsChecked.Add(typeMap) && Validate(new(types, memberMap, configExceptions, typeMap)) && typeMap.ShouldCheckForValid)
+                {
+                    CheckPropertyMaps(typeMap);
+                }
             }
-            typeMapsChecked.Add(typeMap);
-            Validate(new(types, memberMap, typeMap));
-            if(!typeMap.ShouldCheckForValid)
+            else
             {
-                return;
+                var mapperToUse = config.FindMapper(types);
+                if(mapperToUse == null)
+                {
+                    configExceptions.Add(new AutoMapperConfigurationException(memberMap.TypeMap.Types) { MemberMap = memberMap });
+                    return;
+                }
+                if(Validate(new(types, memberMap, configExceptions, ObjectMapper: mapperToUse)) && mapperToUse.GetAssociatedTypes(types) is TypePair newTypes &&
+                    newTypes != types)
+                {
+                    DryRunTypeMap(newTypes, null, memberMap);
+                }
             }
-            CheckPropertyMaps(config, typeMapsChecked, typeMap);
         }
-        else
+        void CheckPropertyMaps(TypeMap typeMap)
         {
-            var mapperToUse = config.FindMapper(types);
-            if (mapperToUse == null)
-            {
-                throw new AutoMapperConfigurationException(memberMap.TypeMap.Types) { MemberMap = memberMap };
-            }
-            Validate(new(types, memberMap, ObjectMapper: mapperToUse));
-            if (mapperToUse.GetAssociatedTypes(types) is TypePair newTypes && newTypes != types)
+            foreach(var memberMap in typeMap.MemberMaps)
             {
-                DryRunTypeMap(config, typeMapsChecked, newTypes, null, memberMap);
+                if(memberMap.Ignored || (memberMap is PropertyMap && typeMap.ConstructorParameterMatches(memberMap.DestinationName)))
+                {
+                    continue;
+                }
+                var sourceType = memberMap.SourceType;
+                // when we don't know what the source type is, bail
+                if(sourceType.IsGenericParameter || sourceType == typeof(object))
+                {
+                    continue;
+                }
+                DryRunTypeMap(new(sourceType, memberMap.DestinationType), null, memberMap);
             }
         }
-    }
-    private void CheckPropertyMaps(IGlobalConfiguration config, HashSet<TypeMap> typeMapsChecked, TypeMap typeMap)
-    {
-        foreach (var memberMap in typeMap.MemberMaps)
+        bool Validate(ValidationContext context)
         {
-            if(memberMap.Ignored || (memberMap is PropertyMap && typeMap.ConstructorParameterMatches(memberMap.DestinationName)))
-            {
-                continue;
-            }
-            var sourceType = memberMap.SourceType;
-            // when we don't know what the source type is, bail
-            if (sourceType.IsGenericParameter || sourceType == typeof(object))
+            foreach(var validator in Expression.Validators)
             {
-                continue;
+                try
+                {
+                    validator(context);
+                }
+                catch(Exception e)
+                {
+                    configExceptions.Add(e);
+                    return false;
+                }
             }
-            DryRunTypeMap(config, typeMapsChecked, new(sourceType, memberMap.DestinationType), null, memberMap);
+            return true;
         }
     }
 }
-public readonly record struct ValidationContext(TypePair Types, MemberMap MemberMap, TypeMap TypeMap = null, IObjectMapper ObjectMapper = null);
+public readonly record struct ValidationContext(TypePair Types, MemberMap MemberMap, List<Exception> Exceptions, TypeMap TypeMap = null, IObjectMapper ObjectMapper = null);
diff --git a/src/AutoMapper/Configuration/MapperConfiguration.cs b/src/AutoMapper/Configuration/MapperConfiguration.cs
@@ -43,7 +43,7 @@ public sealed class MapperConfiguration : IGlobalConfiguration
     private readonly LockingConcurrentDictionary<TypePair, TypeMap> _runtimeMaps;
     private LazyValue<ProjectionBuilder> _projectionBuilder;
     private readonly LockingConcurrentDictionary<MapRequest, Delegate> _executionPlans;
-    private readonly ConfigurationValidator _validator;
+    private readonly MapperConfigurationExpression _configurationExpression;
     private readonly Features<IRuntimeFeature> _features = new();
     private readonly bool _hasOpenMaps;
     private readonly HashSet<TypeMap> _typeMapsPath = [];
@@ -58,14 +58,14 @@ public sealed class MapperConfiguration : IGlobalConfiguration
     private readonly List<Type> _typesInheritance = [];
     public MapperConfiguration(MapperConfigurationExpression configurationExpression)
     {
+        _configurationExpression=configurationExpression;
         var configuration = (IGlobalConfigurationExpression)configurationExpression;
         if (configuration.MethodMappingEnabled != false)
         {
             configuration.IncludeSourceExtensionMethods(typeof(Enumerable));
         }
         _mappers = [..configuration.Mappers];
         _executionPlans = new(CompileExecutionPlan);
-        _validator = new(configuration);
         _projectionBuilder = new(CreateProjectionBuilder);
         Configuration = new((IProfileConfiguration)configuration);
         int typeMapsCount = Configuration.TypeMapsCount;
@@ -155,7 +155,8 @@ static MapperConfigurationExpression Build(Action<IMapperConfigurationExpression
         configure(expr);
         return expr;
     }
-    public void AssertConfigurationIsValid() => _validator.AssertConfigurationExpressionIsValid(this, [.._configuredMaps.Values]);
+    public void AssertConfigurationIsValid() => Validator().AssertConfigurationExpressionIsValid([.._configuredMaps.Values]);
+    ConfigurationValidator Validator() => new(this);
     public IMapper CreateMapper() => new Mapper(this);
     public IMapper CreateMapper(Func<Type, object> serviceCtor) => new Mapper(this, serviceCtor);
     public void CompileMappings()
@@ -218,7 +219,7 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec
             return Lambda(fullExpression, source, destination, ContextParameter);
         }
     }
-    IGlobalConfigurationExpression ConfigurationExpression => _validator.Expression;
+    internal IGlobalConfigurationExpression ConfigurationExpression => _configurationExpression;
     ProjectionBuilder CreateProjectionBuilder() => new(this, [..ConfigurationExpression.ProjectionMappers]);
     IProjectionBuilder IGlobalConfiguration.ProjectionBuilder => _projectionBuilder.Value;
     Func<Type, object> IGlobalConfiguration.ServiceCtor => ConfigurationExpression.ServiceCtor;
@@ -471,14 +472,14 @@ IObjectMapper FindMapper(TypePair types)
         return null;
     }
     void IGlobalConfiguration.RegisterTypeMap(TypeMap typeMap) => _configuredMaps[typeMap.Types] = typeMap;
-    void IGlobalConfiguration.AssertConfigurationIsValid(TypeMap typeMap) => _validator.AssertConfigurationIsValid(this, [typeMap]);
+    void IGlobalConfiguration.AssertConfigurationIsValid(TypeMap typeMap) => Validator().AssertConfigurationIsValid([typeMap]);
     void IGlobalConfiguration.AssertConfigurationIsValid(string profileName)
     {
         if (Array.TrueForAll(Profiles, x => x.Name != profileName))
         {
             throw new ArgumentOutOfRangeException(nameof(profileName), $"Cannot find any profiles with the name '{profileName}'.");
         }
-        _validator.AssertConfigurationIsValid(this, _configuredMaps.Values.Where(typeMap => typeMap.Profile.Name == profileName).ToArray());
+        Validator().AssertConfigurationIsValid(_configuredMaps.Values.Where(typeMap => typeMap.Profile.Name == profileName).ToArray());
     }
     void IGlobalConfiguration.AssertConfigurationIsValid<TProfile>() => this.Internal().AssertConfigurationIsValid(typeof(TProfile).FullName);
     void IGlobalConfiguration.RegisterAsMap(TypeMapConfiguration typeMapConfiguration) =>
diff --git a/src/UnitTests/ConfigurationValidation.cs b/src/UnitTests/ConfigurationValidation.cs
@@ -1,5 +1,40 @@
 namespace AutoMapper.UnitTests.ConfigurationValidation;
+public class When_testing_a_dto_with_mismatched_member_names_and_mismatched_types : AutoMapperSpecBase
+{
+    public class Source
+    {
+        public decimal Foo { get; set; }
+    }
+
+    public class Destination
+    {
+        public Type Foo { get; set; }
+        public string Bar { get; set; }
+    }
 
+    protected override MapperConfiguration CreateConfiguration() =>
+        new(cfg => { cfg.CreateMap<Source, Destination>(); });
+
+    [Fact]
+    public void Should_throw_unmapped_member_and_mismatched_type_exceptions()
+    {
+        new Action(AssertConfigurationIsValid)
+            .ShouldThrow<AggregateException>()
+            .ShouldSatisfyAllConditions(
+                aex => aex.InnerExceptions.ShouldBeOfLength(2),
+                aex => aex.InnerExceptions[0]
+                    .ShouldBeOfType<AutoMapperConfigurationException>()
+                    .ShouldSatisfyAllConditions(
+                        ex => ex.Errors.ShouldBeOfLength(1),
+                        ex => ex.Errors[0].UnmappedPropertyNames.ShouldContain("Bar")),
+                aex => aex.InnerExceptions[1]
+                    .ShouldBeOfType<AutoMapperConfigurationException>()
+                    .ShouldSatisfyAllConditions(
+                        ex => ex.MemberMap.ShouldNotBeNull(),
+                        ex => ex.MemberMap.DestinationName.ShouldBe("Foo"))
+            );
+    }
+}
 public class ConstructorMappingValidation : NonValidatingSpecBase
 {
     public class Destination

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public sealed class MapperConfiguration : IGlobalConfiguration`
`43`	`43`	`private readonly LockingConcurrentDictionary<TypePair, TypeMap> _runtimeMaps;`
`44`	`44`	`private LazyValue<ProjectionBuilder> _projectionBuilder;`
`45`	`45`	`private readonly LockingConcurrentDictionary<MapRequest, Delegate> _executionPlans;`
`46`		`- private readonly ConfigurationValidator _validator;`
	`46`	`+ private readonly MapperConfigurationExpression _configurationExpression;`
`47`	`47`	`private readonly Features<IRuntimeFeature> _features = new();`
`48`	`48`	`private readonly bool _hasOpenMaps;`
`49`	`49`	`private readonly HashSet<TypeMap> _typeMapsPath = [];`
`@@ -58,14 +58,14 @@ public sealed class MapperConfiguration : IGlobalConfiguration`
`58`	`58`	`private readonly List<Type> _typesInheritance = [];`
`59`	`59`	`public MapperConfiguration(MapperConfigurationExpression configurationExpression)`
`60`	`60`	`{`
	`61`	`+ _configurationExpression=configurationExpression;`
`61`	`62`	`var configuration = (IGlobalConfigurationExpression)configurationExpression;`
`62`	`63`	`if (configuration.MethodMappingEnabled != false)`
`63`	`64`	`{`
`64`	`65`	`configuration.IncludeSourceExtensionMethods(typeof(Enumerable));`
`65`	`66`	`}`
`66`	`67`	`_mappers = [..configuration.Mappers];`
`67`	`68`	`_executionPlans = new(CompileExecutionPlan);`
`68`		`- _validator = new(configuration);`
`69`	`69`	`_projectionBuilder = new(CreateProjectionBuilder);`
`70`	`70`	`Configuration = new((IProfileConfiguration)configuration);`
`71`	`71`	`int typeMapsCount = Configuration.TypeMapsCount;`
`@@ -155,7 +155,8 @@ static MapperConfigurationExpression Build(Action<IMapperConfigurationExpression`
`155`	`155`	`configure(expr);`
`156`	`156`	`return expr;`
`157`	`157`	`}`
`158`		`- public void AssertConfigurationIsValid() => _validator.AssertConfigurationExpressionIsValid(this, [.._configuredMaps.Values]);`
	`158`	`+ public void AssertConfigurationIsValid() => Validator().AssertConfigurationExpressionIsValid([.._configuredMaps.Values]);`
	`159`	`+ ConfigurationValidator Validator() => new(this);`
`159`	`160`	`public IMapper CreateMapper() => new Mapper(this);`
`160`	`161`	`public IMapper CreateMapper(Func<Type, object> serviceCtor) => new Mapper(this, serviceCtor);`
`161`	`162`	`public void CompileMappings()`
`@@ -218,7 +219,7 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec`
`218`	`219`	`return Lambda(fullExpression, source, destination, ContextParameter);`
`219`	`220`	`}`
`220`	`221`	`}`
`221`		`- IGlobalConfigurationExpression ConfigurationExpression => _validator.Expression;`
	`222`	`+ internal IGlobalConfigurationExpression ConfigurationExpression => _configurationExpression;`
`222`	`223`	`ProjectionBuilder CreateProjectionBuilder() => new(this, [..ConfigurationExpression.ProjectionMappers]);`
`223`	`224`	`IProjectionBuilder IGlobalConfiguration.ProjectionBuilder => _projectionBuilder.Value;`
`224`	`225`	`Func<Type, object> IGlobalConfiguration.ServiceCtor => ConfigurationExpression.ServiceCtor;`
`@@ -471,14 +472,14 @@ IObjectMapper FindMapper(TypePair types)`
`471`	`472`	`return null;`
`472`	`473`	`}`
`473`	`474`	`void IGlobalConfiguration.RegisterTypeMap(TypeMap typeMap) => _configuredMaps[typeMap.Types] = typeMap;`
`474`		`- void IGlobalConfiguration.AssertConfigurationIsValid(TypeMap typeMap) => _validator.AssertConfigurationIsValid(this, [typeMap]);`
	`475`	`+ void IGlobalConfiguration.AssertConfigurationIsValid(TypeMap typeMap) => Validator().AssertConfigurationIsValid([typeMap]);`
`475`	`476`	`void IGlobalConfiguration.AssertConfigurationIsValid(string profileName)`
`476`	`477`	`{`
`477`	`478`	`if (Array.TrueForAll(Profiles, x => x.Name != profileName))`
`478`	`479`	`{`
`479`	`480`	`throw new ArgumentOutOfRangeException(nameof(profileName), $"Cannot find any profiles with the name '{profileName}'.");`
`480`	`481`	`}`
`481`		`- _validator.AssertConfigurationIsValid(this, _configuredMaps.Values.Where(typeMap => typeMap.Profile.Name == profileName).ToArray());`
	`482`	`+ Validator().AssertConfigurationIsValid(_configuredMaps.Values.Where(typeMap => typeMap.Profile.Name == profileName).ToArray());`
`482`	`483`	`}`
`483`	`484`	`void IGlobalConfiguration.AssertConfigurationIsValid<TProfile>() => this.Internal().AssertConfigurationIsValid(typeof(TProfile).FullName);`
`484`	`485`	`void IGlobalConfiguration.RegisterAsMap(TypeMapConfiguration typeMapConfiguration) =>`