no need to throw to report errors

lbargaoanu · lbargaoanu · commit 1023a52ca64d · 2025-02-14T09:42:31.000+02:00
diff --git a/.editorconfig b/.editorconfig
@@ -86,6 +86,9 @@ dotnet_style_namespace_match_folder = true:silent
 dotnet_style_explicit_tuple_names = true:suggestion
 dotnet_style_prefer_inferred_tuple_names = true:suggestion
 dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_prefer_system_threading_lock = true:suggestion
+csharp_space_after_keywords_in_control_flow_statements = true
 
 [*.xml]
 indent_size = 2
diff --git a/docs/source/Configuration-validation.md b/docs/source/Configuration-validation.md
@@ -55,4 +55,4 @@ To skip validation altogether for this map, use `MemberList.None`. That's the de
 
 ## Custom validations
 
-You can add custom validations through an extension point. See [here](https://github.com/AutoMapper/AutoMapper/blob/bdc0120497d192a2741183415543f6119f50a982/src/UnitTests/CustomValidations.cs#L42).
+You can add custom validations through an extension point. See [here](https://github.com/AutoMapper/AutoMapper/blob/master/src/UnitTests/CustomValidations.cs).
diff --git a/src/AutoMapper/Configuration/ConfigurationValidator.cs b/src/AutoMapper/Configuration/ConfigurationValidator.cs
@@ -13,7 +13,7 @@ public void AssertConfigurationExpressionIsValid(TypeMap[] typeMaps)
             .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.Length != 0)
+        if (duplicateTypeMapConfigs.Length != 0)
         {
             throw new DuplicateTypeMapConfigurationException(duplicateTypeMapConfigs);
         }
@@ -29,49 +29,49 @@ where typeMap.ShouldCheckForValid
              let canConstruct = typeMap.PassesCtorValidation
              where unmappedPropertyNames.Length > 0 || !canConstruct
              select new AutoMapperConfigurationException.TypeMapConfigErrors(typeMap, unmappedPropertyNames, canConstruct)).ToArray();
-        if(badTypeMaps.Length > 0)
+        if (badTypeMaps.Length > 0)
         {
             configExceptions.Add(new AutoMapperConfigurationException(badTypeMaps));
         }
         HashSet<TypeMap> typeMapsChecked = [];
-        foreach(var typeMap in typeMaps)
+        foreach (var typeMap in typeMaps)
         {
             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];
         }
         void DryRunTypeMap(TypePair types, TypeMap typeMap, MemberMap memberMap)
         {
-            if(typeMap == null)
+            if (typeMap == null)
             {
-                if(types.ContainsGenericParameters)
+                if (types.ContainsGenericParameters)
                 {
                     return;
                 }
                 typeMap = config.ResolveTypeMap(types.SourceType, types.DestinationType);
             }
-            if(typeMap != null)
+            if (typeMap != null)
             {
-                if(typeMapsChecked.Add(typeMap) && Validate(new(types, memberMap, configExceptions, typeMap)) && typeMap.ShouldCheckForValid)
+                if (typeMapsChecked.Add(typeMap) && Validate(new(types, memberMap, configExceptions, typeMap)) && typeMap.ShouldCheckForValid)
                 {
                     CheckPropertyMaps(typeMap);
                 }
             }
             else
             {
                 var mapperToUse = config.FindMapper(types);
-                if(mapperToUse == null)
+                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 &&
+                if (Validate(new(types, memberMap, configExceptions, ObjectMapper: mapperToUse)) && mapperToUse.GetAssociatedTypes(types) is TypePair newTypes &&
                     newTypes != types)
                 {
                     DryRunTypeMap(newTypes, null, memberMap);
@@ -80,15 +80,15 @@ void DryRunTypeMap(TypePair types, TypeMap typeMap, MemberMap memberMap)
         }
         void CheckPropertyMaps(TypeMap typeMap)
         {
-            foreach(var memberMap in typeMap.MemberMaps)
+            foreach (var memberMap in typeMap.MemberMaps)
             {
-                if(memberMap.Ignored || (memberMap is PropertyMap && typeMap.ConstructorParameterMatches(memberMap.DestinationName)))
+                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))
+                if (sourceType.IsGenericParameter || sourceType == typeof(object))
                 {
                     continue;
                 }
@@ -97,17 +97,14 @@ void CheckPropertyMaps(TypeMap typeMap)
         }
         bool Validate(ValidationContext context)
         {
-            foreach(var validator in Expression.Validators)
+            try
             {
-                try
-                {
-                    validator(context);
-                }
-                catch(Exception e)
-                {
-                    configExceptions.Add(e);
-                    return false;
-                }
+                Expression.Validators?.Invoke(context);
+            }
+            catch (Exception e)
+            {
+                configExceptions.Add(e);
+                return false;
             }
             return true;
         }
diff --git a/src/AutoMapper/Configuration/MapperConfigurationExpression.cs b/src/AutoMapper/Configuration/MapperConfigurationExpression.cs
@@ -88,22 +88,22 @@ public interface IMapperConfigurationExpression : IProfileExpression
 public sealed class MapperConfigurationExpression : Profile, IGlobalConfigurationExpression
 {
     private readonly List<Profile> _profiles = [];
-    private readonly List<Validator> _validators = [];
+    private Validator _validators;
     private Func<Type, object> _serviceCtor = Activator.CreateInstance;
     private List<IProjectionMapper> _projectionMappers;
     /// <summary>
     /// Add an action to be called when validating the configuration.
     /// </summary>
     /// <param name="validator">the validation callback</param>
     void IGlobalConfigurationExpression.Validator(Validator validator) => 
-        _validators.Add(validator ?? throw new ArgumentNullException(nameof(validator)));
+        _validators += validator ?? throw new ArgumentNullException(nameof(validator));
     /// <summary>
     /// How many levels deep should AutoMapper try to inline the execution plan for child classes.
     /// See <a href="https://automapper.readthedocs.io/en/latest/Understanding-your-mapping.html">the docs</a> for details.
     /// </summary>
     int IGlobalConfigurationExpression.MaxExecutionPlanDepth { get; set; } = 1;
 
-    List<Validator> IGlobalConfigurationExpression.Validators => _validators;
+    Validator IGlobalConfigurationExpression.Validators => _validators;
 
     List<IProjectionMapper> IGlobalConfigurationExpression.ProjectionMappers => _projectionMappers ??= ProjectionBuilder.DefaultProjectionMappers();
 
diff --git a/src/AutoMapper/Internal/InternalApi.cs b/src/AutoMapper/Internal/InternalApi.cs
@@ -36,7 +36,7 @@ public interface IGlobalConfigurationExpression : IMapperConfigurationExpression
     /// See <a href="https://automapper.readthedocs.io/en/latest/Understanding-your-mapping.html">the docs</a> for details.
     /// </summary>
     int MaxExecutionPlanDepth { get; set; }
-    List<Validator> Validators { get; }
+    Validator Validators { get; }
     List<IProjectionMapper> ProjectionMappers { get; }
     /// <summary>
     /// How many levels deep should recursive queries be expanded.
diff --git a/src/UnitTests/ConfigurationValidation.cs b/src/UnitTests/ConfigurationValidation.cs
diff --git a/src/UnitTests/CustomValidations.cs b/src/UnitTests/CustomValidations.cs

Original file line number	Diff line number	Diff line change
@@ -55,4 +55,4 @@ To skip validation altogether for this map, use `MemberList.None`. That's the de
`55`	`55`
`56`	`56`	`## Custom validations`
`57`	`57`
`58`		`-You can add custom validations through an extension point. See [here](https://github.com/AutoMapper/AutoMapper/blob/bdc0120497d192a2741183415543f6119f50a982/src/UnitTests/CustomValidations.cs#L42).`
	`58`	`+You can add custom validations through an extension point. See [here](https://github.com/AutoMapper/AutoMapper/blob/master/src/UnitTests/CustomValidations.cs).`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public void AssertConfigurationExpressionIsValid(TypeMap[] typeMaps)`
`13`	`13`	`.Select(g => (TypePair: g.Key, ProfileNames: g.Select(tmc => tmc.profile.ProfileName).ToArray()))`
`14`	`14`	`.Select(g => new DuplicateTypeMapConfigurationException.TypeMapConfigErrors(g.TypePair, g.ProfileNames))`
`15`	`15`	`.ToArray();`
`16`		`- if(duplicateTypeMapConfigs.Length != 0)`
	`16`	`+ if (duplicateTypeMapConfigs.Length != 0)`
`17`	`17`	`{`
`18`	`18`	`throw new DuplicateTypeMapConfigurationException(duplicateTypeMapConfigs);`
`19`	`19`	`}`
`@@ -29,49 +29,49 @@ where typeMap.ShouldCheckForValid`
`29`	`29`	`let canConstruct = typeMap.PassesCtorValidation`
`30`	`30`	`where unmappedPropertyNames.Length > 0 \|\| !canConstruct`
`31`	`31`	`select new AutoMapperConfigurationException.TypeMapConfigErrors(typeMap, unmappedPropertyNames, canConstruct)).ToArray();`
`32`		`- if(badTypeMaps.Length > 0)`
	`32`	`+ if (badTypeMaps.Length > 0)`
`33`	`33`	`{`
`34`	`34`	`configExceptions.Add(new AutoMapperConfigurationException(badTypeMaps));`
`35`	`35`	`}`
`36`	`36`	`HashSet<TypeMap> typeMapsChecked = [];`
`37`		`- foreach(var typeMap in typeMaps)`
	`37`	`+ foreach (var typeMap in typeMaps)`
`38`	`38`	`{`
`39`	`39`	`DryRunTypeMap(typeMap.Types, typeMap, null);`
`40`	`40`	`}`
`41`		`- if(configExceptions.Count > 1)`
	`41`	`+ if (configExceptions.Count > 1)`
`42`	`42`	`{`
`43`	`43`	`throw new AggregateException(configExceptions);`
`44`	`44`	`}`
`45`		`- if(configExceptions.Count > 0)`
	`45`	`+ if (configExceptions.Count > 0)`
`46`	`46`	`{`
`47`	`47`	`throw configExceptions[0];`
`48`	`48`	`}`
`49`	`49`	`void DryRunTypeMap(TypePair types, TypeMap typeMap, MemberMap memberMap)`
`50`	`50`	`{`
`51`		`- if(typeMap == null)`
	`51`	`+ if (typeMap == null)`
`52`	`52`	`{`
`53`		`- if(types.ContainsGenericParameters)`
	`53`	`+ if (types.ContainsGenericParameters)`
`54`	`54`	`{`
`55`	`55`	`return;`
`56`	`56`	`}`
`57`	`57`	`typeMap = config.ResolveTypeMap(types.SourceType, types.DestinationType);`
`58`	`58`	`}`
`59`		`- if(typeMap != null)`
	`59`	`+ if (typeMap != null)`
`60`	`60`	`{`
`61`		`- if(typeMapsChecked.Add(typeMap) && Validate(new(types, memberMap, configExceptions, typeMap)) && typeMap.ShouldCheckForValid)`
	`61`	`+ if (typeMapsChecked.Add(typeMap) && Validate(new(types, memberMap, configExceptions, typeMap)) && typeMap.ShouldCheckForValid)`
`62`	`62`	`{`
`63`	`63`	`CheckPropertyMaps(typeMap);`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`else`
`67`	`67`	`{`
`68`	`68`	`var mapperToUse = config.FindMapper(types);`
`69`		`- if(mapperToUse == null)`
	`69`	`+ if (mapperToUse == null)`
`70`	`70`	`{`
`71`	`71`	`configExceptions.Add(new AutoMapperConfigurationException(memberMap.TypeMap.Types) { MemberMap = memberMap });`
`72`	`72`	`return;`
`73`	`73`	`}`
`74`		`- if(Validate(new(types, memberMap, configExceptions, ObjectMapper: mapperToUse)) && mapperToUse.GetAssociatedTypes(types) is TypePair newTypes &&`
	`74`	`+ if (Validate(new(types, memberMap, configExceptions, ObjectMapper: mapperToUse)) && mapperToUse.GetAssociatedTypes(types) is TypePair newTypes &&`
`75`	`75`	`newTypes != types)`
`76`	`76`	`{`
`77`	`77`	`DryRunTypeMap(newTypes, null, memberMap);`
`@@ -80,15 +80,15 @@ void DryRunTypeMap(TypePair types, TypeMap typeMap, MemberMap memberMap)`
`80`	`80`	`}`
`81`	`81`	`void CheckPropertyMaps(TypeMap typeMap)`
`82`	`82`	`{`
`83`		`- foreach(var memberMap in typeMap.MemberMaps)`
	`83`	`+ foreach (var memberMap in typeMap.MemberMaps)`
`84`	`84`	`{`
`85`		`- if(memberMap.Ignored \|\| (memberMap is PropertyMap && typeMap.ConstructorParameterMatches(memberMap.DestinationName)))`
	`85`	`+ if (memberMap.Ignored \|\| (memberMap is PropertyMap && typeMap.ConstructorParameterMatches(memberMap.DestinationName)))`
`86`	`86`	`{`
`87`	`87`	`continue;`
`88`	`88`	`}`
`89`	`89`	`var sourceType = memberMap.SourceType;`
`90`	`90`	`// when we don't know what the source type is, bail`
`91`		`- if(sourceType.IsGenericParameter \|\| sourceType == typeof(object))`
	`91`	`+ if (sourceType.IsGenericParameter \|\| sourceType == typeof(object))`
`92`	`92`	`{`
`93`	`93`	`continue;`
`94`	`94`	`}`
`@@ -97,17 +97,14 @@ void CheckPropertyMaps(TypeMap typeMap)`
`97`	`97`	`}`
`98`	`98`	`bool Validate(ValidationContext context)`
`99`	`99`	`{`
`100`		`- foreach(var validator in Expression.Validators)`
	`100`	`+ try`
`101`	`101`	`{`
`102`		`- try`
`103`		`- {`
`104`		`- validator(context);`
`105`		`- }`
`106`		`- catch(Exception e)`
`107`		`- {`
`108`		`- configExceptions.Add(e);`
`109`		`- return false;`
`110`		`- }`
	`102`	`+ Expression.Validators?.Invoke(context);`
	`103`	`+ }`
	`104`	`+ catch (Exception e)`
	`105`	`+ {`
	`106`	`+ configExceptions.Add(e);`
	`107`	`+ return false;`
`111`	`108`	`}`
`112`	`109`	`return true;`
`113`	`110`	`}`