feat: #938 - Add DirectAssignmentForSameType setting parametr

Author: DocSvartz

src/Mapster.Tests/WhenConfiguringMapping.cs

@@ -142,9 +142,9 @@ public void NewInstanceConfigurationTest()
             obj.Name = "Tim";
             obj.Child = new TestNewInstanceF() { Name = "Kıvanç" };
 
-            TypeAdapterConfig<TestNewInstanceD, TestNewInstanceE>
+                TypeAdapterConfig<TestNewInstanceD, TestNewInstanceE>
                 .NewConfig()
-                .ShallowCopyForSameType(true);
+                .ShallowCopyForSameType(true); 
 
             var newObj2 = TypeAdapter.Adapt<TestNewInstanceD, TestNewInstanceE>(obj);
 
@@ -156,6 +156,28 @@ public void NewInstanceConfigurationTest()
             Assert.IsTrue(newObj2.Child.Name == "Antalya");
         }
 
+        [TestMethod]
+        public void WhenDirectAssignmentForSameTypeConfigurate()
+        {
+            TestNewInstanceD obj = new TestNewInstanceD();
+            obj.Name = "Tim";
+            obj.Child = new TestNewInstanceF() { Name = "Kıvanç" };
+
+            var config = new TypeAdapterConfig();
+            config.NewConfig<TestNewInstanceF, TestNewInstanceF>()
+            .DirectAssignmentForSameType(true);
+
+            var newObj2 = TypeAdapter.Adapt<TestNewInstanceD, TestNewInstanceE>(obj, config);
+
+            Assert.IsTrue(newObj2.Name == "Tim");
+            Assert.IsTrue(obj.Child.Name == newObj2.Child.Name);
+
+            obj.Child.Name = "Antalya";
+
+            Assert.IsTrue(newObj2.Child.Name == "Antalya");
+        }
+
+
         #region Data
 
         private Source _source;

src/Mapster/Adapters/BaseAdapter.cs

@@ -495,10 +495,19 @@ internal Expression CreateAdaptExpression(Expression source, Type destinationTyp
             if (_source.Type == destinationType && arg.MapType == MapType.Projection)
                 return _source;
 
+            TypeAdapterRule? rule;
+            var tuple = new TypeTuple(_source.Type, destinationType);
+            arg.Context.Config.RuleMap.TryGetValue(tuple, out rule);
+
             //adapt(_source);
             var notUsingDestinationValue = mapping is not { UseDestinationValue: true };
-            var exp = _source.Type == destinationType && arg.Settings.ShallowCopyForSameType == true && notUsingDestinationValue &&
-                      !arg.Context.Config.HasRuleFor(_source.Type, destinationType)
+
+            if(_source.Type == destinationType && notUsingDestinationValue
+                && arg.IsDirectAssignmentForSameTypeEnable(rule, tuple) && arg.IsNotCustomConverterFactory(rule))
+                return _source.To(destinationType);
+
+           var exp = _source.Type == destinationType && arg.Settings.ShallowCopyForSameType == true && notUsingDestinationValue 
+                     && rule == null
                 ? _source
                 : CreateAdaptExpressionCore(_source, destinationType, arg, mapping, destination);
 

src/Mapster/TypeAdapterSetter.cs

@@ -108,6 +108,14 @@ public static TSetter ShallowCopyForSameType<TSetter>(this TSetter setter, bool
             return setter;
         }
 
+        public static TSetter DirectAssignmentForSameType<TSetter>(this TSetter setter, bool value) where TSetter : TypeAdapterSetter
+        {
+            setter.CheckCompiled();
+
+            setter.Settings.DirectAssignmentForSameType = value;
+            return setter;
+        }
+
         public static TSetter EnumMappingStrategy<TSetter>(this TSetter setter, EnumMappingStrategy strategy) where TSetter : TypeAdapterSetter
         {
             setter.CheckCompiled();

src/Mapster/TypeAdapterSettings.cs

@@ -39,11 +39,18 @@ public bool? PreserveReference
             get => Get(nameof(PreserveReference));
             set => Set(nameof(PreserveReference), value);
         }
+        public bool? DirectAssignmentForSameType
+        {
+            get => Get(nameof(DirectAssignmentForSameType));
+            set => Set(nameof(DirectAssignmentForSameType), value);
+        }
+
         public bool? ShallowCopyForSameType
         {
             get => Get(nameof(ShallowCopyForSameType));
             set => Set(nameof(ShallowCopyForSameType), value);
         }
+
         public bool? IgnoreNullValues
         {
             get => Get(nameof(IgnoreNullValues));

src/Mapster/Utils/ReflectionUtils.cs

@@ -466,5 +466,33 @@ public static bool IsNotSelfCreation(this Type type)
 
             return type.GetFieldsAndProperties().All(it => (it.SetterModifier & (AccessModifier.Public | AccessModifier.NonPublic)) == 0);
         }
+
+        public static bool IsDirectAssignmentForSameTypeEnable(this CompileArgument arg, TypeAdapterRule? rule, TypeTuple tuple)
+        {
+
+            if (rule != null)
+            {
+                var contexSettings = arg.Context.Config.Rules.Where(x => x.Settings.SourceType == tuple.Source && x.Settings.DestinationType == tuple.Destination).Select(x => x.Settings).FirstOrDefault();
+                return (rule?.Settings.DirectAssignmentForSameType).GetValueOrDefault() || (contexSettings?.DirectAssignmentForSameType).GetValueOrDefault();
+            } 
+
+            if (arg.Context.Config.Default.Settings.DirectAssignmentForSameType.GetValueOrDefault())
+                return true;
+
+            return false;
+        }
+
+        public static bool IsNotCustomConverterFactory(this CompileArgument arg, TypeAdapterRule? rule)
+        {
+            if(rule != null)
+            {
+                if(arg.MapType == MapType.Map && rule.Settings.ConverterFactory != null)
+                    return false;
+                if (arg.MapType == MapType.MapToTarget && rule.Settings.ConverterToTargetFactory != null)
+                    return false;
+            }
+
+            return true;
+        }
     }
 }