feat: impliment Map with Type mapping settings ovveride

Author: DocSvartz

src/Mapster/Adapters/BaseClassAdapter.cs

@@ -43,6 +43,12 @@ src is LambdaExpression lambda
                         from src in sources
                         select fn(src, destinationMember, arg))
                     .FirstOrDefault(result => result != null);
+                if(getter is MemberExpression mem && mem?.Expression?.Type == source.Type)
+                {
+                    getter = Expression.PropertyOrField(source, mem.Member.Name);
+                }
+
+              var   test = resolvers.Where(ValueAccessingStrategy.CustomResolvers.Contains);
 
                 if (arg.MapType == MapType.Projection && getter != null)
                 {
@@ -103,6 +109,10 @@ select fn(src, destinationMember, arg))
                 var nextResolvers = arg.Settings.Resolvers.Next(arg.Settings.Ignore, (ParameterExpression)source, destinationMember.Name)
                     .ToList();
 
+                var overideSettings = arg.Settings.Resolvers
+                    .Where(x => x.DestinationMemberName == destinationMember.Name && x.OvverideSettings != null)
+                    .Select(x=>x.OvverideSettings).FirstOrDefault();
+
                 var propertyModel = new MemberMapping
                 {
                     DestinationMember = destinationMember,
@@ -112,6 +122,7 @@ select fn(src, destinationMember, arg))
                     Source = (ParameterExpression)source,
                     Destination = (ParameterExpression?)destination,
                     UseDestinationValue = IsCanUsingDestinationValue(arg, destinationMember),
+                    OverrideSettings = overideSettings
                 };
                 if(arg.MapType == MapType.ApplyNullPropagation &&
                     getter == null && !arg.DestinationType.IsRecordType()  
@@ -264,6 +275,7 @@ protected Expression CreateInstantiationExpression(Expression source, ClassMappi
                     else
                        getter = member.Getter
                             .ApplyNullPropagationFromCtor(CreateAdaptExpressionCore(member.Getter, member.DestinationMember.Type, arg, member), arg);
+
 
 
                     if (member.Ignore.Condition != null)
@@ -282,6 +294,7 @@ protected Expression CreateInstantiationExpression(Expression source, ClassMappi
                         if (arg.MapType == MapType.MapToTarget && arg.DestinationType.IsRecordType())
                            getter = TryRestoreRecordMember(member.DestinationMember, recordRestorParamModel, destination) ?? getter;
                     }
+
                 }
                 arguments.Add(getter);
             }

src/Mapster/Models/InvokerModel.cs

@@ -9,6 +9,7 @@ public class InvokerModel
         public LambdaExpression? Invoker { get; set; }
         public string? SourceMemberName { get; set; }
         public LambdaExpression? Condition { get; set; }
+        public TypeAdapterSettings? OvverideSettings { get; set; }
         public bool IsChildPath { get; set; }
 
         public InvokerModel? Next(ParameterExpression source, string destMemberName)

src/Mapster/Models/MemberMapping.cs

@@ -13,6 +13,7 @@ internal class MemberMapping
         public ParameterExpression Source;
         public ParameterExpression? Destination;
         public bool UseDestinationValue;
+        public TypeAdapterSettings? OverrideSettings;
 
         public bool HasSettings()
         {

src/Mapster/TypeAdapterConfig.cs

@@ -474,6 +474,13 @@ internal LambdaExpression CreateInlineMapExpression(Type sourceType, Type destin
                     arg.Settings.Resolvers.AddRange(mapping.NextResolvers);
                     arg.Settings.Ignore.Apply(mapping.NextIgnore);
                     arg.UseDestinationValue = mapping.UseDestinationValue;
+
+                    if (mapping.OverrideSettings != null)
+                    {
+                        mapping.OverrideSettings.Apply(arg.Settings);
+                        arg.Settings = mapping.OverrideSettings;
+                    }
+                        
                 }
 
                 return CreateMapExpression(arg);

src/Mapster/TypeAdapterSetter.cs

@@ -642,7 +642,7 @@ public TypeAdapterSetter<TDestination> IgnoredRemove(params Expression<Func<TDes
         public TypeAdapterSetter<TSource, TDestination> MapOverride<TDestinationMember, TSourceMember>(
             Expression<Func<TDestination, TDestinationMember>> member,
             Expression<Func<TSource, TSourceMember>> source,
-            Action<TypeAdapterSetter<TSourceMember, TDestinationMember>>? configAction = null)
+            Action<OverrideTypesSetter<TSourceMember, TDestinationMember>>? configAction = null)
         {
             this.CheckCompiled();
 
@@ -653,20 +653,22 @@ public TypeAdapterSetter<TSource, TDestination> MapOverride<TDestinationMember,
                 return this;
             }
 
+            TypeAdapterSettings? overrideSettings = null;
+
             if (configAction != null)
             {
-                var settings = TypeAdapterSetter.CreateMapTypeOverride<TSourceMember, TDestinationMember>();
-
-                configAction(settings);
+                var Tempsetter = new OverrideTypesSetter<TSourceMember, TDestinationMember>();
+                configAction(Tempsetter);
 
+                overrideSettings = Tempsetter.Settings;
             }
 
-
             Settings.Resolvers.Add(new InvokerModel
             {
                 DestinationMemberName = member.GetMemberPath()!,
                 Invoker = invoker,
-                Condition = null
+                Condition = null,
+                OvverideSettings = overrideSettings
             });
             return this;
         }

src/Mapster/TypeAdapterSetters/OverrideTypesSetter.cs

@@ -0,0 +1,35 @@
+using Mapster.Utils;
+using System;
+using System.Linq.Expressions;
+
+namespace Mapster
+{
+    [AdaptWith(AdaptDirectives.DestinationAsRecord)]
+    public class OverrideTypesSetter : TypeAdapterSetter
+    {
+        protected OverrideTypesSettings _Settings { get => (OverrideTypesSettings)Settings; }
+
+        public OverrideTypesSetter() : this (new OverrideTypesSettings (), null) { }
+        public OverrideTypesSetter(TypeAdapterSettings settings, TypeAdapterConfig config) : base(settings, config) { }
+    }
+
+    public class OverrideTypesSetter<TSource, TDestination> : OverrideTypesSetter
+    {
+        public OverrideTypesSetter<TSource, TDestination> DropSettings(params Expression<Func<TypeAdapterSettings, object>>[] settings)
+        {
+            foreach (var member in settings)
+            {
+                _Settings.DropSettings.Add(member.GetMemberPath()!);
+            }
+
+            return this;
+        }
+
+        public TypeAdapterSetter<TSource, TDestination> Configurate()
+        {
+            return new TypeAdapterSetter<TSource, TDestination>(this.Settings,this.Config);
+        }
+    }
+
+    
+}

src/Mapster/TypeAdapterSettings/OverrideTypesSettings.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace Mapster
+{
+    [AdaptWith(AdaptDirectives.DestinationAsRecord)]
+    public class OverrideTypesSettings : TypeAdapterSettings
+    {
+        public List<string> DropSettings
+        {
+            get => Get(nameof(DropSettings), () => new List<string>());
+        }
+
+
+
+    }
+}

src/Mapster/Utils/ExpressionEx.cs

@@ -150,7 +150,7 @@ public static Expression Not(Expression exp)
         public static Expression Apply(this LambdaExpression lambda, MapType mapType, params Expression[] exps)
         {
             return lambda.Apply(mapType != MapType.Projection, exps);
-        }
+            }
 
         public static Expression Apply(this LambdaExpression lambda, ParameterExpression p1, ParameterExpression? p2 = null)
         {