Map property using specific method

[harrison314]

Hello,
i tried mapperly to replace automapper.

I'm missing a functionality that would be able to descriptively specify property mapping using a method.

eg.

[Mapper(EnumMappingStrategy = EnumMappingStrategy.ByName, UseDeepCloning = true)]
public partial class DtoMapper
{
    
    [MapPropertyUsing(Target = "Name", Method = nameof(ToLowecase) )]
    public partial CalculateSimmilarityReq MapToObject(CalculateSimmilarityReqDto dto);

    private string ToLowecase(string src) //or string ToLowecase(CalculateSimmilarityReqDto source,)
    {
     // ...
    }
}

A similar functionality can be using the "Before / after map" scenario, but that would violate the DRY principle.

[latonz]

Currently we prioritize other features higher than this. We may reconsider this at a later point.

[fergalmoran]

Yes - this would be very useful for us, as it's currently blocking us from using Mapperly.
We have a lot of string to string mappings required for image urls so the type mapping currently provided isn't enough.

[latonz]

Could you explain your use case in more detail? What modifications do you need to be done inside the mapping? Is it only a single property of an object, all of a type, only some?
In the meantime you could before/after map be used to address your use case?

[fergalmoran]

Hi Lars... sure!
We have entities with a number of different image properties which can be served from different sources depending on a number of conditions.. so we would have a Map along the lines of

   RearImage = Entity.ResolveImage(this.Id, ImageKinds.Rear),
   TopImage = Entity.ResolveImage(this.Id, ImageKinds.Top

where we round robin the image sources among other metrics.
I looked at the before/aftermap but I'm not sure how I would go about this? I presume if we use that we lose static & extension methods?

[latonz]

Although I‘m not really sure if this should belong to a Mapper you should be able to do it via After-Map without loosing the static/extension methods. The same concepts apply:

[Mapper]
public static partial class YourMapper
{
    public static YourDto Map(this YourModel model)
    {
        var dto = model.MapInternal();
        dto.RearImage = Entity.ResolveImage(model.Id, ImageKinds.Rear);
        dto.TopImage = Entity.ResolveImage(model.Id, ImageKinds.Top);
        return dto;
    }

    [MapperIgnoreTarget(nameof(YourDto.RearImage))]
    [MapperIgnoreTarget(nameof(YourDto.TopImage))]
    private static partial YourDto MapInternal(this YourModel model);
}

[fergalmoran]

Okay - wow! I see this.. I'll take it for a spin and see how we get on, thanks ever so much. This is great!!
I know you're right about it not being the job of a mapper but it's just been so handy for us , it's hard to imaging not having it any more.

[waxingsatirical]

This would be useful for me too. I want to convert a bool in the source to an int in the target, I know I can do it with a general type converter, but I only want it for a specific property, so seems a bit overkill. I can also do it in before/after map pattern, but also need to add an ignore for the property.. so it's a bit clunky.

[ryan-morris]

I came looking for this as well. A lot of our properties are required init so a before/after allows for build errors in the generated mapper without the initial value being set somehow. For now it seems like the only option is to implement the mapping manually in these cases.

Just for reference, some of our 'special' cases are based around 2 properties being consolidated into a single one. Example below is how we resolved the issue in a proof of concept using mapster. I am not recommending following the mapster pattern to handle these scenarios, just providing this is a reference.

public class Source
{
    public required double Speed { get; init; }

    public required SpeedUnit SpeedUnit { get; init; } // speed unit is an enum
}

public class Destination
{
    public required double SpeedMph { get; init; }
}

with mapster:

TypeAdapterConfig<Source, Destination>
                .ForType()
                .Map(dest => dest.SpeedMph, src => SpeedCalculator.Convert(src.Speed, src.SpeedUnit, SpeedUnit.MPH));

[latonz]

Handled in #783