MapFrom should override ignore

Author: lbargaoanu

src/AutoMapper/Configuration/CtorParamConfigurationExpression.cs

@@ -45,12 +45,12 @@ public CtorParamConfigurationExpression(string ctorParamName, Type sourceType)
     }
 
     public void MapFrom<TMember>(Expression<Func<TSource, TMember>> sourceMember) =>
-        _ctorParamActions.Add(cpm => cpm.SetResolver(sourceMember));
+        _ctorParamActions.Add(cpm => cpm.MapFrom(sourceMember));
 
     public void MapFrom<TMember>(Func<TSource, ResolutionContext, TMember> resolver)
     {
         Expression<Func<TSource, TDestination, TMember, ResolutionContext, TMember>> resolverExpression = (src, dest, destMember, ctxt) => resolver(src, ctxt);
-        _ctorParamActions.Add(cpm => cpm.Resolver = new FuncResolver(resolverExpression));
+        _ctorParamActions.Add(cpm => cpm.SetResolver(new FuncResolver(resolverExpression)));
     }
 
     public void MapFrom(string sourceMembersPath)

src/AutoMapper/Configuration/MemberConfigurationExpression.cs

@@ -24,7 +24,7 @@ public MemberConfigurationExpression(MemberInfo destinationMember, Type sourceTy
     public void MapFrom<TValueResolver>() where TValueResolver : IValueResolver<TSource, TDestination, TMember> =>
         MapFromCore(new(typeof(TValueResolver), typeof(IValueResolver<TSource, TDestination, TMember>)));
     protected void MapFromCore(ClassValueResolver config) => SetResolver(config);
-    protected void SetResolver(IValueResolver config) => PropertyMapActions.Add(pm => pm.Resolver = config);
+    protected void SetResolver(IValueResolver config) => PropertyMapActions.Add(pm => pm.SetResolver(config));
     public void MapFrom<TValueResolver, TSourceMember>(Expression<Func<TSource, TSourceMember>> sourceMember)
         where TValueResolver : IMemberValueResolver<TSource, TDestination, TSourceMember, TMember> =>
             MapFromCore<TValueResolver, TSourceMember>(sourceMember);

src/AutoMapper/Configuration/TypeMapConfiguration.cs

@@ -185,7 +185,7 @@ private void ReverseSourceMembers(MemberPath memberPath, LambdaExpression custom
 
             var pathMap = reverseTypeMap.FindOrCreatePathMapFor(forPathLambda, memberPath, reverseTypeMap);
 
-            pathMap.SetResolver(customExpression);
+            pathMap.MapFrom(customExpression);
         });
     }
     protected void ForSourceMemberCore(string sourceMemberName, Action<ISourceMemberConfigurationExpression> memberOptions)

src/AutoMapper/MemberMap.cs

@@ -10,7 +10,12 @@ public class MemberMap : IValueResolver
     public TypeMap TypeMap { get; protected set; }
     public LambdaExpression CustomMapExpression => Resolver?.ProjectToExpression;
     public bool IsResolveConfigured => Resolver != null && Resolver != this;
-    public void SetResolver(LambdaExpression lambda) => Resolver = new ExpressionResolver(lambda);
+    public void MapFrom(LambdaExpression lambda) => SetResolver(new ExpressionResolver(lambda));
+    public void SetResolver(IValueResolver resolver)
+    {
+        Resolver = resolver;
+        Ignored = false;
+    }
     public virtual Type SourceType => default;
     public virtual MemberInfo[] SourceMembers { get => Array.Empty<MemberInfo>(); set { } }
     public virtual IncludedMember IncludedMember => null;
@@ -27,22 +32,17 @@ public class MemberMap : IValueResolver
     public virtual object NullSubstitute { get => default; set { } }
     public virtual LambdaExpression PreCondition { get => default; set { } }
     public virtual LambdaExpression Condition { get => default; set { } }
-    public IValueResolver Resolver { get; set; }
+    public IValueResolver Resolver { get; protected set; }
     public virtual IReadOnlyCollection<ValueTransformerConfiguration> ValueTransformers => Array.Empty<ValueTransformerConfiguration>();
     public MemberInfo SourceMember => Resolver?.GetSourceMember(this);
     public string GetSourceMemberName() => Resolver?.SourceMemberName ?? SourceMember?.Name;
     public bool MustUseDestination => UseDestinationValue is true || !CanBeSet;
-    public void MapFrom(LambdaExpression sourceMember)
-    {
-        SetResolver(sourceMember);
-        Ignored = false;
-    }
     public void MapFrom(string sourceMembersPath, MemberInfo[] members)
     {
         var sourceType = TypeMap.SourceType;
         var sourceMembers = sourceType.ContainsGenericParameters ? members :
             members[0].DeclaringType.ContainsGenericParameters ? ReflectionHelper.GetMemberPath(sourceType, sourceMembersPath, TypeMap) : members;
-        Resolver = new MemberPathResolver(sourceMembers);
+        SetResolver(new MemberPathResolver(sourceMembers));
     }
     public override string ToString() => DestinationName;
     public Expression ChainSourceMembers(Expression source) => SourceMembers.Chain(source);

src/AutoMapper/QueryableExtensions/ProjectionBuilder.cs

@@ -245,7 +245,7 @@ void ReplaceSubQueries()
                 {
                     var letProperty = letType.GetProperty(letMapInfo.Property.Name);
                     var letPropertyMap = letTypeMap.FindOrCreatePropertyMapFor(letProperty, letMapInfo.Property.Type);
-                    letPropertyMap.SetResolver(Lambda(letMapInfo.LetExpression.ReplaceParameters(letMapInfo.MapFromSource), secondParameter));
+                    letPropertyMap.MapFrom(Lambda(letMapInfo.LetExpression.ReplaceParameters(letMapInfo.MapFromSource), secondParameter));
                     projection = projection.Replace(letMapInfo.Marker, Property(secondParameter, letProperty));
                 }
                 projection = new ReplaceMemberAccessesVisitor(instanceParameter, secondParameter).Visit(projection);

src/UnitTests/MappingInheritance/OverrideIgnore.cs

@@ -1,38 +1,45 @@
 namespace AutoMapper.UnitTests.Bug;
-
-public class OverrideIgnore
+public class OverrideIgnoreMapFromString
 {
     public class DomainBase
     {
         public string SomeProperty { get; set; }
     }
-
     public class DtoBase
     {
         public string SomeDifferentProperty { get; set; }
     }
-
     [Fact]
     public void specifying_map_should_override_ignore()
     {
         var config = new MapperConfiguration(cfg => cfg.CreateMap<DomainBase, DtoBase>()
             .ForMember(m=>m.SomeDifferentProperty, m=>m.Ignore())
-            .ForMember(m=>m.SomeDifferentProperty, m=>m.MapFrom(s=>s.SomeProperty)));
+            .ForMember(m=>m.SomeDifferentProperty, m=>m.MapFrom("SomeProperty")));
 
         var dto = config.CreateMapper().Map<DomainBase, DtoBase>(new DomainBase {SomeProperty = "Test"});
 
-        "Test".ShouldBe(dto.SomeDifferentProperty);
+        dto.SomeDifferentProperty.ShouldBe("Test");
+    }
+}
+public class OverrideIgnore
+{
+    public class DomainBase
+    {
+        public string SomeProperty { get; set; }
+    }
+    public class DtoBase
+    {
+        public string SomeDifferentProperty { get; set; }
     }
-
     [Fact]
-    public void specifying_map_should_override_ignore_with_one_parameter()
+    public void specifying_map_should_override_ignore()
     {
         var config = new MapperConfiguration(cfg => cfg.CreateMap<DomainBase, DtoBase>()
-            .ForMember(m => m.SomeDifferentProperty, m => m.Ignore())
-            .ForMember(m => m.SomeDifferentProperty, m => m.MapFrom(s => s.SomeProperty)));
+            .ForMember(m=>m.SomeDifferentProperty, m=>m.Ignore())
+            .ForMember(m=>m.SomeDifferentProperty, m=>m.MapFrom(s=>s.SomeProperty)));
 
-        var dto = config.CreateMapper().Map<DtoBase>(new DomainBase { SomeProperty = "Test" });
+        var dto = config.CreateMapper().Map<DomainBase, DtoBase>(new DomainBase {SomeProperty = "Test"});
 
-        "Test".ShouldBe(dto.SomeDifferentProperty);
+        dto.SomeDifferentProperty.ShouldBe("Test");
     }
-}
+}