Fix Issue #783 - Add new Feature RequireExplicitMappingPrimitive to config

src/Mapster.Tests/WhenExplicitMappingRequired.cs

@@ -13,6 +13,7 @@ public class WhenExplicitMappingRequired
         public void TestCleanup()
         {
             TypeAdapterConfig.GlobalSettings.RequireExplicitMapping = false;
+            TypeAdapterConfig.GlobalSettings.RequireExplicitMappingPrimitive = false;
             TypeAdapterConfig.GlobalSettings.Clear();
         }
 
@@ -140,8 +141,60 @@ public void UnmappedChildPocoShouldFailed()
             setter.Compile(); // Should fail here
         }
 
+        [TestMethod]
+        public void RequireExplicitMappingPrimitiveWork()
+        {
+            TypeAdapterConfig.GlobalSettings.RequireExplicitMappingPrimitive = true;
+
+            TypeAdapterConfig<Source783, Destination783>.NewConfig();
+
+            Should.Throw<CompileException>(() => 
+            {
+                TypeAdapterConfig.GlobalSettings.Compile(); // throw CompileException
+            });
+
+            byte byteSource = 10;
+
+            byteSource.Adapt<byte>(); // Should work when the type is mapped to itself
+
+            Should.Throw<CompileException>(() =>
+            {
+                byteSource.Adapt<int>();  // throw CompileException, Do not map to another primitive type without registering the configuration
+            });
+
+            Should.NotThrow(() =>
+            {
+                TypeAdapterConfig<byte, int>.NewConfig(); 
+
+                byteSource.Adapt<int>();  // Not throw CompileException when config is registering
+            });
+
+            Should.NotThrow(() =>
+            {
+                TypeAdapterConfig<Source783, Destination783>.NewConfig()
+                    .Map(dest=> dest.MyProperty, src=> int.Parse(src.MyProperty)); 
+                // it work works because int.Parse return Type Int. Type is mapped to itself (int -> int) without config.
+
+                var sourceMapconfig = new Source783() { MyProperty = "128" };
+                var resultMapconfig = sourceMapconfig.Adapt<Destination783>();
+
+                resultMapconfig.MyProperty.ShouldBe(128);
+            });
+
+        }
+
+
         #region TestClasses
+
+        public class Source783
+        {
+            public string MyProperty { get; set; } = "";
+        }
 
+        public class Destination783
+        {
+            public int MyProperty { get; set; }
+        }
 
         public enum NameEnum
         {

src/Mapster/Adapters/PrimitiveAdapter.cs

@@ -18,6 +18,8 @@ protected override bool CanMap(PreCompileArgument arg)
 
         protected override Expression CreateExpressionBody(Expression source, Expression? destination, CompileArgument arg)
         {
+            if (arg.SourceType != arg.DestinationType && arg.Context.Config.RequireExplicitMappingPrimitive && !arg.ExplicitMapping)
+                throw new InvalidOperationException("Implicit mapping is not allowed (check GlobalSettings.RequireExplicitMapping) and no configuration exists");
 
             if (arg.Settings.MapToTargetPrimitive == true)
             {

src/Mapster/TypeAdapterConfig.cs

@@ -82,6 +82,7 @@ private static List<TypeAdapterRule> CreateRuleTemplate()
 
         public bool RequireDestinationMemberSource { get; set; }
         public bool RequireExplicitMapping { get; set; }
+        public bool RequireExplicitMappingPrimitive { get; set; }
         public bool AllowImplicitDestinationInheritance { get; set; }
         public bool AllowImplicitSourceInheritance { get; set; } = true;
         public bool SelfContainedCodeGeneration { get; set; }
@@ -495,7 +496,7 @@ private LambdaExpression CreateMapInvokeExpression(Type sourceType, Type destina
 
         internal Expression CreateMapInvokeExpressionBody(Type sourceType, Type destinationType, Expression p)
         {
-            if (RequireExplicitMapping)
+            if (RequireExplicitMapping || RequireExplicitMappingPrimitive)
             {
                 var key = new TypeTuple(sourceType, destinationType);
                 _mapDict[key] = Compiler(CreateMapExpression(key, MapType.Map));
@@ -518,7 +519,7 @@ internal Expression CreateMapInvokeExpressionBody(Type sourceType, Type destinat
 
         internal Expression CreateMapToTargetInvokeExpressionBody(Type sourceType, Type destinationType, Expression p1, Expression p2)
         {
-            if (RequireExplicitMapping)
+            if (RequireExplicitMapping || RequireExplicitMappingPrimitive)
             {
                 var key = new TypeTuple(sourceType, destinationType);
                 _mapToTargetDict[key] = Compiler(CreateMapExpression(key, MapType.MapToTarget));