fail not work

Author: DocSvartz

src/Mapster/Adapters/BaseClassAdapter.cs

@@ -137,7 +137,7 @@ select fn(src, destinationMember, arg))
                 }
                 if (getter != null)
                 {
-                    propertyModel.Getter = arg.MapType == MapType.Projection 
+                    propertyModel.Getter = arg.MapType == MapType.Projection  || ctorMapping
                         ? getter 
                         : getter.ApplyPropertyNullPropagation(arg, source);
                     properties.Add(propertyModel);

src/Mapster/Utils/DirectParameterMemberFinder.cs

@@ -4,118 +4,76 @@
 
 public class DirectParameterMemberFinder : ExpressionVisitor
 {
+    private readonly bool _expression;
+
     private readonly Stack<bool> _isInsideParameterChain = new();
     private readonly HashSet<Expression> _TargetParams;
     public List<Expression> FoundMembers { get; } = new();
 
-
     public DirectParameterMemberFinder(params Expression[] targetParams)
     {
         _TargetParams = new HashSet<Expression>(targetParams);
     }
 
-    protected override Expression VisitParameter(ParameterExpression node)
-    {
-        _isInsideParameterChain.Push(true);
-        var result = base.VisitParameter(node);
-        _isInsideParameterChain.Pop();
-        return result;
-    }
+    
 
     protected override Expression VisitMember(MemberExpression node)
     {
-        if (node.Expression is ParameterExpression || _isInsideParameterChain.Any(x => x))
-        {
-            FoundMembers.Add(node);
-        }
+        var getParam = new GetParametr();
 
-        _isInsideParameterChain.Push(_isInsideParameterChain.Any(x => x));
-        this.Visit(node.Expression);
-        _isInsideParameterChain.Pop();
-        return node;
-    }
+        var param = getParam.GetParam(node.Expression);
 
-    protected override Expression VisitIndex(IndexExpression node)
-    {
-        if (_isInsideParameterChain.Any(x => x))
-        {
+        if (_TargetParams.Contains(param))
             FoundMembers.Add(node);
-        }
 
-        _isInsideParameterChain.Push(_isInsideParameterChain.Any(x => x));
-        this.Visit(node.Object);
-        foreach (var argument in node.Arguments)
-        {
-            this.Visit(argument);
-        }
-        _isInsideParameterChain.Pop();
         return node;
+
     }
 
+   
+
     protected override Expression VisitUnary(UnaryExpression node)
     {
         if (node.NodeType == ExpressionType.Convert || node.NodeType == ExpressionType.ConvertChecked)
         {
-            _isInsideParameterChain.Push(_isInsideParameterChain.Any(x => x));
+            bool parentWasInChain = _isInsideParameterChain.Any(x => x);
+            _isInsideParameterChain.Push(parentWasInChain);
             var result = base.VisitUnary(node);
             _isInsideParameterChain.Pop();
             return result;
         }
         return base.VisitUnary(node);
     }
-
-    protected override Expression VisitBinary(BinaryExpression node)
+       
+    public IEnumerable<Expression> Find(Expression expression)
     {
-        this.Visit(node.Left);
-        this.Visit(node.Right);
-        return node;
+        FoundMembers.Clear();
+        Visit(expression);
+
+        // Теперь фильтрация проще: благодаря правильному порядку обхода в VisitMember,
+        // в список попадают только те члены, которые висят над параметром.
+        return FoundMembers;
     }
+}
+
 
-    protected override Expression VisitMethodCall(MethodCallExpression node)
+
+public class GetParametr : ExpressionVisitor
+{
+    private Expression parametr;
+
+    protected override Expression VisitParameter(ParameterExpression node)
     {
-        if (node.Object != null)
-        {
-            this.Visit(node.Object);
-        }
-        foreach (var arg in node.Arguments)
-        {
-            this.Visit(arg);
-        }
+
+        parametr = node;
+
         return node;
     }
 
-    public IEnumerable<Expression> Find(Expression expression)
+    public Expression GetParam(Expression expression)
     {
-        FoundMembers.Clear();
         Visit(expression);
-        return FoundMembers
-            .Where(m =>
-            {
-                var current = m;
-
-                // Поднимаемся вверх по дереву выражения до самого корня этого MemberAccess
-                while (current != null)
-                {
-                    if (current is ParameterExpression p && _TargetParams.Contains(p))
-                    {
-                        return true; // Нашли целевой параметр в цепочке
-                    }
-
-                    if (current is MemberExpression nextMember)
-                    {
-                        current = nextMember.Expression;
-                    }
-                    else if (current is UnaryExpression unary &&
-                             (unary.NodeType == ExpressionType.Convert || unary.NodeType == ExpressionType.ConvertChecked))
-                    {
-                        current = unary.Operand;
-                    }
-                    else
-                    {
-                        break;
-                    }
-                }
-                return false;
-            });
-    }
+
+        return parametr;
+    } 
 }

src/Mapster/Utils/ExpressionEx.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Data.SqlTypes;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -430,12 +431,13 @@ public static Expression ApplyPropertyNullPropagation(this Expression getter, Co
             var finder = new DirectParameterMemberFinder(source);
             var condition2 = finder.Find(getter)
                 .Select(x => x.GetNullPropagationChecks(arg))
+                .Where(x => x != null)
                 .ToArray().ConcatPropagationChecks();
 
             if (condition2 == null)
                 return getter;
 
-            if (!getter.CanBeNull())
+            if (!getter.Type.CanBeNull())
             {
                 var transform = Expression.Convert(getter, typeof(Nullable<>).MakeGenericType(getter.Type));
                 return Expression.Condition(condition2, transform, transform.Type.CreateDefault());