start scan Cuncurency

Author: DocSvartz

src/Mapster.Tests/WhenRegisteringAndMappingRace.cs

@@ -1,8 +1,9 @@
-using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Shouldly;
+using System;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Threading.Tasks;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Shouldly;
 
 namespace Mapster.Tests
 {
@@ -131,11 +132,53 @@ public void Explicit_Mapping_Requirementd()
                 }
         }
 
+        [TestMethod]
+        public void Scan_Explicit_Mapping_Requirementd()
+        {
+
+            TypeAdapterConfigFactory.GlobalSettings.RequireExplicitMapping = true;
+            TypeAdapterConfigFactory.GlobalSettings.RequireDestinationMemberSource = true;
+
+            var simplePoco = new WhenAddingCustomMappings.SimplePoco { Id = Guid.NewGuid(), Name = "TestName" };
+
+            TypeAdapterConfigFactory.GlobalSettings.Scan(Assembly.GetExecutingAssembly());
+
+            //TypeAdapter.Adapt<WhenAddingCustomMappings.SimplePoco, WeirdPoco>(simplePoco);
+
+            for (int i = 0; i < 100; i++)
+            {
+                Parallel.Invoke(
+                     () =>
+                     {
+                         TypeAdapterConfigFactory.GlobalSettings.ScanConcurrency(Assembly.GetExecutingAssembly());
+
+                     },
+                     () =>
+                     {
+                         TypeAdapter.Adapt<WeirdPoco>(simplePoco);
+                     }
+                     );
+            }
+        }
+
     }
 
 
     #region TestClasses
 
+    public class RegData : IRegister
+    {
+        public void Register(ITypeAdapterConfig config)
+        {
+            config.NewConfig<WhenAddingCustomMappings.SimplePoco, WeirdPoco>()
+            .Map(dest => dest.IHaveADifferentId, src => src.Id)
+            .Map(dest => dest.MyNamePropertyIsDifferent, src => src.Name)
+            .Ignore(dest => dest.Children);
+            
+        }
+    }
+
+
     public class SimplePoco
     {
         public Guid Id { get; set; }

src/Mapster/TypeAdapterConfig/TypeAdapterConfig.cs

@@ -237,7 +237,10 @@ public ITypeAdapterConfig Clone()
 
         private ConcurrentDictionary<string, ITypeAdapterConfig>? _inlineConfigs;
         private ConcurrentDictionary<string, ITypeAdapterConfig> InlineConfigs =>
-            _inlineConfigs ??= new ConcurrentDictionary<string, ITypeAdapterConfig>(); 
+            _inlineConfigs ??= new ConcurrentDictionary<string, ITypeAdapterConfig>();
+
+        bool IConfigConcurrency.IsScanConcurrency { get; set; }
+
         public ITypeAdapterConfig Fork(Action<ITypeAdapterConfig> action,
 #if !NET40
             [CallerFilePath]
@@ -386,5 +389,7 @@ public static void Clear()
     internal interface IConfigConcurrency
     {
         public bool ConcurrencyEnvironment { get; set; }
+
+        public bool IsScanConcurrency { get; set; }
     }
 }

src/Mapster/TypeAdapterConfig/TypeAdapterConfigIRegisterExtentions.cs

@@ -36,13 +36,44 @@ public static void Apply(this ITypeAdapterConfig config, IEnumerable<Lazy<IRegis
         /// <returns>A list of registered mappings</returns>
         public static IList<IRegister> Scan(this ITypeAdapterConfig config, params Assembly[] assemblies)
         {
-            List<IRegister> registers = assemblies.Select(assembly => assembly.GetLoadableTypes()
+            if (config.ConcurrencyEnvironment)
+            {
+                config.Configure.WaitOne(-1, false);
+            }
+
+                List<IRegister> registers = assemblies.Select(assembly => assembly.GetLoadableTypes()
                 .Where(x => typeof(IRegister).GetTypeInfo().IsAssignableFrom(x.GetTypeInfo()) && x.GetTypeInfo().IsClass && !x.GetTypeInfo().IsAbstract))
                 .SelectMany(registerTypes =>
                     registerTypes.Select(registerType => (IRegister)Activator.CreateInstance(registerType))).ToList();
 
             config.Apply(registers);
             return registers;
         }
+
+        public static IList<IRegister> ScanConcurrency(this ITypeAdapterConfig config, params Assembly[] assemblies)
+        {
+           
+
+            if (config is IConfigConcurrency cfg)
+            {
+                cfg.ConcurrencyEnvironment = true;
+                config.Configure.WaitOne(-1);
+                cfg.IsScanConcurrency = true;
+            }
+
+            try
+            {
+                return config.Scan(assemblies);
+            }
+            finally
+            {
+                if (config is IConfigConcurrency cfg2)
+                {
+                    config.Configure.Set();
+                    cfg2.ConcurrencyEnvironment = false;
+                }
+            }
+
+        }
     }
 }

src/Mapster/TypeAdapterConfig/TypeAdapterConfigTSetterExtentions.cs

@@ -15,10 +15,10 @@ public static class TypeAdapterConfigTSetterExtentions
         /// <returns></returns>
         public static TypeAdapterSetter NewConfig(this ITypeAdapterConfig config, Type sourceType, Type destinationType)
         {
-            if (config.ConcurrencyEnvironment)
+            if (config.ConcurrencyEnvironment && config is IConfigConcurrency cfg)
             {
-               // config.AdaptMutex.WaitOne(-1);
-                config.Configure.WaitOne(-1, false);
+               if(!cfg.IsScanConcurrency)
+                  config.Configure.WaitOne(-1, false);
             }
 
             config.Remove(sourceType, destinationType);
@@ -33,10 +33,10 @@ public static TypeAdapterSetter NewConfig(this ITypeAdapterConfig config, Type s
         /// <returns></returns>
         public static TypeAdapterSetter<TSource, TDestination> NewConfig<TSource, TDestination>(this ITypeAdapterConfig config) 
         {
-            if (config.ConcurrencyEnvironment)
+            if (config.ConcurrencyEnvironment && config is IConfigConcurrency cfg)
             {
-              //  config.AdaptMutex.WaitOne(-1);
-                config.Configure.WaitOne(-1, false);
+                if (!cfg.IsScanConcurrency)
+                    config.Configure.WaitOne(-1, false);
             }
 
             config.Remove(typeof(TSource), typeof(TDestination));