refactoring

Author: DocSvartz

src/Mapster.Tests/WhenRegisteringAndMappingRace.cs

@@ -15,7 +15,8 @@ public void TestCleanup()
             TypeAdapterConfigFactory.GlobalSettings.Clear();
             TypeAdapterConfigFactory.GlobalSettings.RequireExplicitMapping = false;
             TypeAdapterConfigFactory.GlobalSettings.RequireDestinationMemberSource = false;
-            TypeAdapterConfigFactory.GlobalSettings.ConcurencyEnviroment = false;
+            if(TypeAdapterConfigFactory.GlobalSettings is IConfigConcurrency config)
+                config.ConcurrencyEnvironment = false;
         }
 
 
@@ -98,11 +99,10 @@ public void Explicit_Mapping_Requirementd()
 
             TypeAdapterConfigFactory.GlobalSettings.RequireExplicitMapping = true;
             TypeAdapterConfigFactory.GlobalSettings.RequireDestinationMemberSource = true;
-            TypeAdapterConfigFactory.GlobalSettings.ConcurencyEnviroment = true;
 
             var simplePoco = new WhenAddingCustomMappings.SimplePoco { Id = Guid.NewGuid(), Name = "TestName" };
 
-            TypeAdapterConfig<WhenAddingCustomMappings.SimplePoco, WeirdPoco>.NewConfig()
+            TypeAdapterConfigConcurrency<WhenAddingCustomMappings.SimplePoco, WeirdPoco>.NewConfig()
 
                                  .Map(dest => dest.IHaveADifferentId, src => src.Id)
                                  .Map(dest => dest.MyNamePropertyIsDifferent, src => src.Name)
@@ -116,8 +116,7 @@ public void Explicit_Mapping_Requirementd()
                     Parallel.Invoke(
                          () =>
                          {
-                             TypeAdapterConfig<WhenAddingCustomMappings.SimplePoco, WeirdPoco>.NewConfig()
-                             //.Ignore(dest => dest.Children)
+                             TypeAdapterConfigConcurrency<WhenAddingCustomMappings.SimplePoco, WeirdPoco>.NewConfig()
                                  .Map(dest => dest.IHaveADifferentId, src => src.Id)
                                  .Map(dest => dest.MyNamePropertyIsDifferent, src => src.Name)
                                  .Ignore(dest => dest.Children)

src/Mapster/TypeAdapterConfig/BaseTypeAdapterConfigDecorator.cs

@@ -39,7 +39,7 @@ public BaseTypeAdapterConfigDecorator(ITypeAdapterConfig config, bool IsGlobal =
 
         public bool SelfContainedCodeGeneration { get => _Config.SelfContainedCodeGeneration; set => _Config.SelfContainedCodeGeneration = value; }
         public Func<LambdaExpression, Delegate> Compiler { get => _Config.Compiler; set => _Config.Compiler = value; }
-        public bool ConcurencyEnviroment { get => _Config.ConcurencyEnviroment; set => _Config.ConcurencyEnviroment = value; }
+        public bool ConcurrencyEnvironment { get => _Config.ConcurrencyEnvironment; }
 
         public AutoResetEvent Configure => _Config.Configure;
 

src/Mapster/TypeAdapterConfig/ITypeAdapterConfig.cs

@@ -25,7 +25,7 @@ public interface ITypeAdapterConfig
         public IEnumerable<TypeAdapterRule> GetRules(Func<TypeAdapterRule, bool> predicate);
         bool SelfContainedCodeGeneration { get; set; }
 
-        bool ConcurencyEnviroment { get; set; }
+        bool ConcurrencyEnvironment { get; }
         AutoResetEvent Configure {  get;}
         AutoResetEvent AdaptMutex { get; }
 

src/Mapster/TypeAdapterConfig/TypeAdapterConfig.cs

@@ -10,7 +10,7 @@
 
 namespace Mapster
 {
-    public class TypeAdapterConfig : ITypeAdapterConfig
+    public class TypeAdapterConfig : ITypeAdapterConfig, IConfigConcurrency
     {
         [AdaptIgnore]
         public bool IsGlobalSettings { get; private set; }
@@ -29,7 +29,7 @@ public class TypeAdapterConfig : ITypeAdapterConfig
         [AdaptIgnore]
         public ConfigCompileStorage ConfigCompile { get; private set; }
 
-        public bool ConcurencyEnviroment {  get; set; }
+        public bool ConcurrencyEnvironment {  get;  set; }
 
         [AdaptIgnore]
         public AutoResetEvent Configure { get; private set; }
@@ -86,7 +86,7 @@ public TypeAdapterSetter<TSource, TDestination> ForType<TSource, TDestination>()
 
         public LambdaExpression CreateMapExpression(TypeTuple tuple, MapType mapType)
         {
-            if (ConcurencyEnviroment)
+            if (ConcurrencyEnvironment)
             {
                 Configure.WaitOne(-1);
                /// AdaptMutex.WaitOne(-1, false);
@@ -110,7 +110,7 @@ public LambdaExpression CreateMapExpression(TypeTuple tuple, MapType mapType)
             }
             finally
             {
-                if (ConcurencyEnviroment)
+                if (ConcurrencyEnvironment)
                 {
                     AdaptMutex.Set();
                     Configure.Set();
@@ -325,6 +325,9 @@ public static class TypeAdapterConfig<TSource, TDestination>
 		/// <returns></returns>
 		public static TypeAdapterSetter<TSource, TDestination> NewConfig()
         {
+            if (TypeAdapterConfigFactory.GlobalSettings is IConfigConcurrency config)
+                config.ConcurrencyEnvironment = false;
+
             return TypeAdapterConfigFactory.GlobalSettings.NewConfig<TSource, TDestination>();
         }
 
@@ -335,6 +338,9 @@ public static TypeAdapterSetter<TSource, TDestination> NewConfig()
 		/// <returns></returns>
 		public static TypeAdapterSetter<TSource, TDestination> ForType()
         {
+            if (TypeAdapterConfigFactory.GlobalSettings is IConfigConcurrency config)
+                config.ConcurrencyEnvironment = false;
+
             return TypeAdapterConfigFactory.GlobalSettings.ForType<TSource, TDestination>();
         }
 
@@ -347,4 +353,45 @@ public static void Clear()
             TypeAdapterConfigFactory.GlobalSettings.Remove(typeof(TSource), typeof(TDestination));
         }
     }
+
+    public static class TypeAdapterConfigConcurrency<TSource, TDestination>
+    {
+        /// <summary>
+        ///  Creates a new configuration for mapping between the source and destination types.
+        /// </summary>
+        /// <returns></returns>
+        public static TypeAdapterSetter<TSource, TDestination> NewConfig()
+        {
+            if (TypeAdapterConfigFactory.GlobalSettings is IConfigConcurrency config)
+                config.ConcurrencyEnvironment = true;
+
+            return TypeAdapterConfigFactory.GlobalSettings.NewConfig<TSource, TDestination>();
+        }
+
+
+        /// <summary>
+        /// Creates a configuration for mapping between the source and destination types.
+        /// </summary>
+        /// <returns></returns>
+        public static TypeAdapterSetter<TSource, TDestination> ForType()
+        {
+            if (TypeAdapterConfigFactory.GlobalSettings is IConfigConcurrency config)
+                config.ConcurrencyEnvironment = true;
+            return TypeAdapterConfigFactory.GlobalSettings.ForType<TSource, TDestination>();
+        }
+
+
+        /// <summary>
+        /// Clears the type mapping configuration for the specified source and destination types.
+        /// </summary>
+        public static void Clear()
+        {
+            TypeAdapterConfigFactory.GlobalSettings.Remove(typeof(TSource), typeof(TDestination));
+        }
+    }
+
+    internal interface IConfigConcurrency
+    {
+        public bool ConcurrencyEnvironment { get; set; }
+    }
 }

src/Mapster/TypeAdapterConfig/TypeAdapterConfigTSetterExtentions.cs

@@ -15,7 +15,7 @@ public static class TypeAdapterConfigTSetterExtentions
         /// <returns></returns>
         public static TypeAdapterSetter NewConfig(this ITypeAdapterConfig config, Type sourceType, Type destinationType)
         {
-            if (config.ConcurencyEnviroment)
+            if (config.ConcurrencyEnvironment)
             {
                // config.AdaptMutex.WaitOne(-1);
                 config.Configure.WaitOne(-1, false);
@@ -33,7 +33,7 @@ public static TypeAdapterSetter NewConfig(this ITypeAdapterConfig config, Type s
         /// <returns></returns>
         public static TypeAdapterSetter<TSource, TDestination> NewConfig<TSource, TDestination>(this ITypeAdapterConfig config) 
         {
-            if (config.ConcurencyEnviroment)
+            if (config.ConcurrencyEnvironment)
             {
               //  config.AdaptMutex.WaitOne(-1);
                 config.Configure.WaitOne(-1, false);

src/Mapster/TypeAdapterSetter.cs

@@ -41,7 +41,7 @@ public static TSetter BreakConfig<TSetter>(this TSetter setter) where TSetter :
             }
             finally
             {
-                if (setter.Config.ConcurencyEnviroment)
+                if (setter.Config.ConcurrencyEnvironment)
                 {
                     setter.Config.Configure.Set();
                     setter.Config.AdaptMutex.Set();