push to 10.1.0

src/Directory.Build.props

@@ -2,7 +2,7 @@
 	<PropertyGroup>
 		<!-- Properties related to build/pack -->
         <IsPackable>false</IsPackable>
-		<Version>10.1.0-pre02</Version>
+		<Version>10.0.12</Version>
 		<MapsterPluginsTFMs>netstandard2.0;net10.0;net9.0;net8.0</MapsterPluginsTFMs>
 		<MapsterTFMs>netstandard2.0;net10.0;net9.0;net8.0</MapsterTFMs>
 		<MapsterEFCoreTFMs>net10.0;net9.0;net8.0</MapsterEFCoreTFMs>

src/Mapster.Tests/WhenIgnoringConditionally.cs

@@ -172,6 +172,43 @@ public void IgnoreIf_Apply_To_RecordType()
             dto.Name.ShouldBeNull();
         }
 
+        // Regression test for https://github.com/MapsterMapper/Mapster/issues/1007
+        // Unlike SimpleRecord above (which maps every member through the primary
+        // constructor), NativeRecord is a real C# `record` whose Name property is
+        // NOT part of the primary constructor — it's a plain settable auto-property.
+        // Members mapped that way go through RecordTypeAdapter.RecordInlineExpression,
+        // a separate code path from constructor-argument mapping, which used to
+        // ignore member.Ignore.Condition entirely.
+        [TestMethod]
+        public void IgnoreIf_Apply_To_RecordType_Property_Not_In_Constructor_Map()
+        {
+            TypeAdapterConfig<SimplePoco, NativeRecord>.NewConfig()
+                .IgnoreIf((src, dest) => src.Name == "TestName", dest => dest.Name)
+                .Compile();
+
+            var poco = new SimplePoco { Id = 1, Name = "TestName" };
+            var dto = TypeAdapter.Adapt<SimplePoco, NativeRecord>(poco);
+
+            dto.Id.ShouldBe(1);
+            dto.Name.ShouldBeNull();
+        }
+
+        [TestMethod]
+        public void IgnoreIf_Apply_To_RecordType_Property_Not_In_Constructor_MapToTarget()
+        {
+            TypeAdapterConfig<SimplePoco, NativeRecord>.NewConfig()
+                .IgnoreIf((src, dest) => src.Name == "TestName", dest => dest.Name)
+                .Compile();
+
+            var poco = new SimplePoco { Id = 1, Name = "TestName" };
+            var dto = new NativeRecord { Id = 999, Name = "DtoName" };
+
+            var result = TypeAdapter.Adapt(poco, dto);
+
+            result.Id.ShouldBe(1);
+            result.Name.ShouldBe("DtoName");
+        }
+
         #endregion
 
 
@@ -202,6 +239,12 @@ public SimpleRecord(int id, string name)
             }
         }
 
+        public record NativeRecord
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+
         #endregion
 
     }

src/Mapster/Adapters/RecordTypeAdapter.cs

@@ -48,7 +48,7 @@
             }
 
 
             return RecordInlineExpression(source, destination, arg, installExpr); // Activator field when not include in public ctor
         }
 
         private Expression? RecordInlineExpression(Expression source, Expression? destination, CompileArgument arg, Expression installExpr)
@@ -96,13 +96,35 @@
                                 binEx.Right is ConstantExpression { Value: null })
                                 adapt = condEx.IfFalse;
                         }
                         var destinationCompareNull = Expression.Equal(destination, Expression.Constant(null, destination.Type));
                         var sourceCondition = Expression.NotEqual(member.Getter, Expression.Constant(null, member.Getter.Type));
                         var destinationCanbeNull = Expression.Condition(destinationCompareNull, member.DestinationMember.Type.CreateDefault(arg), member.DestinationMember.GetExpression(destination));
                         adapt = Expression.Condition(sourceCondition, adapt, destinationCanbeNull);
                     }
                 }
 
+                // IgnoreIf(...) support — unlike ClassAdapter (which drops the whole
+                // member statement into an `if (!condition) { ... }` block), record
+                // members are bound inline inside a MemberInit, so the condition is
+                // expressed as a ternary: keep the computed value when the condition
+                // is false, otherwise fall back to whatever the member should be left
+                // as (the existing destination value for MapToTarget, or the type's
+                // default value when constructing a brand-new instance).
+                if (arg.MapType != MapType.Projection && member.Ignore.Condition != null)
+                {
+                    var conditionDestination = destination ?? arg.DestinationType.CreateDefault();
+                    var conditionBody = member.Ignore.IsChildPath
+                        ? member.Ignore.Condition.Body
+                        : member.Ignore.Condition.Apply(arg.MapType, source, conditionDestination);
+                    var notIgnored = ExpressionEx.Not(conditionBody);
+
+                    var fallback = arg.MapType == MapType.MapToTarget && destination != null
+                        ? member.DestinationMember.GetExpression(destination)
+                        : member.DestinationMember.Type.CreateDefault();
+
+                    adapt = Expression.Condition(notIgnored, adapt, fallback);
+                }
+
                 //special null property check for projection
                 //if we don't set null to property, EF will create empty object
                 //except collection type & complex type which cannot be null
@@ -145,7 +167,7 @@
                    contructorMembers.Any(x => string.Equals(x.Name, member.Name, StringComparison.InvariantCultureIgnoreCase)))
                     continue;
 
                 lines.Add(Expression.Bind((MemberInfo)member.Info, Expression.MakeMemberAccess(destination, (MemberInfo)member.Info)));
             }
 
             return lines;
@@ -192,9 +214,9 @@
 
                             if (arg.MapType == MapType.MapToTarget)
                             {
                                 var var2Param = ClassConverterContext.Members.Where(x => x.DestinationMember.Name == member.DestinationMember.Name).FirstOrDefault();
 
                                 Expression destMemberVar2 = var2Param.DestinationMember.GetExpression(var2Param.Destination);
                                 var ParamLambdaVar2 = destMemberVar2;
                                 if(member.DestinationMember.Type.IsRecordType())
                                     ParamLambdaVar2 = arg.Context.Config.CreateMapInvokeExpressionBody(member.Getter.Type, member.DestinationMember.Type, destMemberVar2);