Mapster.Tool - PropertySettingBuilder.Map(member, mapFunc, targetPropertyName) method is not working as expected!

[atiyar]

I'm using -
Mapster 10.0.12
Mapster.Tool 10.0.12
.NET 10.0.400

I have the following entity model -

public class User
{
    public int Id { get; set; }
    public string Email { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

and I wanted the following DTO model -

public partial class UserDto
{
    public int Id { get; set; }
    public string Email { get; set; }
    public string FullName { get; set; }
    public int Age { get; set; }
}

and a mapper extension method to be generated which would map User.FirstName + " " + User.LastName to UserDto.FullName.

I used the following code -

public class UserCodeGenConfig : ICodeGenerationRegister
{
    public void Register(CodeGenerationConfig config)
    {
        config.AdaptTo("[name]Dto", MapType.Map)
            .ForType<User>(p =>
            {
                p.Ignore(s => s.FirstName);
                p.Map(s => s.LastName, s => $"{s.FirstName} {s.LastName}", "FullName");
            });

        config.GenerateMapper("[name]Mapper")
            .ForType<User>();
    }
}

and used the model and extension generating commands with Mapster.Tool. Following are the generated codes -

public partial class UserDto
{
    public int Id { get; set; }
    public string Email { get; set; }
    public string FullName { get; set; }
    public int Age { get; set; }
}

public static partial class UserMapper
{
    public static UserDto AdaptToDto(this User p1)
    {
        return p1 == null ? null : new UserDto()
        {
            Id = p1.Id,
            Email = p1.Email,
            FullName = p1.LastName,
            Age = p1.Age
        };
    }
}

As you can see, the DTO model is generated as expected, but the mapping code is exactly what it would generate if I had used -

p.Map(s => s.LastName, "FullName");

instead of -

p.Map(s => s.LastName, s => $"{s.FirstName} {s.LastName}", "FullName");

Following is the source code documentation for the Map method in question -

/// <summary>
/// Map a specific property of the source type to a target property using a custom mapping function.
/// </summary>
/// <typeparam name="TReturn">Type of source property.</typeparam>
/// <typeparam name="TReturn2">Type of target property type.</typeparam>
/// <param name="member">A lambda expression that identifies the source property to be mapped.</param>
/// <param name="mapFunc">A lambda expression that defines the custom mapping function.</param>
/// <param name="targetPropertyName">The name of the target property to which the source property should be mapped.</param>
/// <returns></returns>
public PropertySettingBuilder<T> Map<TReturn, TReturn2>(Expression<Func<T, TReturn>> member, Expression<Func<T, TReturn2>> mapFunc, string? targetPropertyName = null);

So, it seems the tool is not respecting the 2nd parameter (Expression<Func<T, TReturn2>> mapFunc) of this Map method.

Is there anything I failed to understand or is this a bug? Is there any other approach to achieve the expected result?

[DocSvartz]

@andrerav Should this function do the same thing as a regular Map() - provide an alternative source for the destination member?

If so, it should look like this:

new InvokerModel
  {
      DestinationMemberName = setting.TargetPropertyName ?? name,
      // SourceMemberName = name,  // need remove it
      Invoker = setting.MapFunc,
  }

/// A lambda expression that identifies the source property to be mapped.
/// A lambda expression that defines the custom mapping function.

From the description it follows that it is something similar to MapWith() in local context (now it not exist) 🤔

[DocSvartz]

HI, @atiyar.

public static partial class UserMapper
{
    public static UserDto AdaptToDto(this User p1)
    {
        return p1 == null ? null : new UserDto()
        {
            Id = p1.Id,
            Email = p1.Email,
            FullName = string.Format("{0} {1}", p1.FirstName, p1.LastName),
            Age = p1.Age
        };
    }
}

Is this expected behavior?

[atiyar]

HI, @atiyar.

public static partial class UserMapper
{
    public static UserDto AdaptToDto(this User p1)
    {
        return p1 == null ? null : new UserDto()
        {
            Id = p1.Id,
            Email = p1.Email,
            FullName = string.Format("{0} {1}", p1.FirstName, p1.LastName),
            Age = p1.Age
        };
    }
}

Is this expected behavior?

I was hoping so, yes. Isn't that what the method's documentation says?
I'm not sure if I did fail to understand anything. I'm a new user of Mapster.

[DocSvartz]

@atiyar

Isn't that what the method's documentation says?

In terms of how it works, Map() in Mapster lib isn't intended to define a mapping function (a transforming function).
In essence, Map() is intended to create a mapping function parameter, and the source expression itself is passed to this function for transformation.

.NewConfig()
.Map(s => s.LastName, s => $"{s.FirstName} {s.LastName}")

// It equal next request
// For the LastName property, need to create a mapping function with the following signature:
string MapFunc(string p1) : where p1 == $"{s.FirstName} {s.LastName}")

In the current example, since the source type and the destination member type are the same, and string is essentially an immutable type, the optimization that involves using direct assignment is enabled:

 FullName = MappingFunc( $"{s.FirstName} {s.LastName}" ),

// optimized presentation

FullName =  $"{s.FirstName} {s.LastName}" ,

[atiyar]

@DocSvartz

Just to make sure, you did notice that I'm using that Map() method in an ICodeGenerationRegister implementation, and not in an IRegister implementation, right?

You and I are talking about two different Map() methods here, and I don't know if they work the same under the hood (I didn't go through the source code) -

The Map() method you are referring to (the link you provided) is a member of the TypeAdapterSetter class, and is used to define custom mapping configuration between existing Source and Destination types, and I do understand how those Map() methods work.

The Map() method I posted the issue is about is an overload in the PropertySettingBuilder class. This class has three overloads of Map() method, and they are used when generating code for models and extension methods using the FluentAPI approach.

Again, I don't know if the two work the same under the hood, just making sure we are on the same page here.

Note: by "documentation" I meant the "summary" documentation above that specific method signature I posted, not the official documentation of Mapster. The official documentation is here. but it doesn't include that specific overload in question.

[DocSvartz]

Again, I don't know if the two work the same under the hood, just making sure we are on the same page here.

Yes, we are talking about the same thing.

It's just that the description, in my opinion, doesn't quite correspond to what this method does.

@andrerav Should this function do the same thing as a regular Map() - provide an alternative source for the destination member?

Because if this is an analogue of the method Map() from the main library , then the solution to this problem will be the one I've indicated. If it's something else, then the solution to the problem will have to be different.