no need to throw to report errors

Author: lbargaoanu

.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

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).

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,13 +97,13 @@ void CheckPropertyMaps(TypeMap typeMap)
         }
         bool Validate(ValidationContext context)
         {
-            foreach(var validator in Expression.Validators)
+            foreach (var validator in Expression.Validators)
             {
                 try
                 {
                     validator(context);
                 }
-                catch(Exception e)
+                catch (Exception e)
                 {
                     configExceptions.Add(e);
                     return false;