Converter could access types being mapped

[tompetko]

Convert method of custom type converter should be called with TypePair or be accessible in ResolutionContext. This is useful when mapping between generic type and object.

Source/destination types

class UpdateUser
{
    public Setting<string> Name { get; set; }
    public Setting<UpdateAddress> Address { get; set; }
}

class UpdateAddress
{
    public Setting<string> Street { get; set; }
}

class CreateUser
{
    public string Name { get; set; }
    public CreateAddress Address { get; set; }
}

class CreateAddress
{
    public Setting<string> Street { get; set; }
}

public class SettingToObjectConverter<T> : ITypeConverter<Setting<T>, object>
{
    public object Convert(Setting<T> source, object destination, ResolutionContext context)
    {
        var destinationType = destination?.GetType();

        // Destination type could not be determined for nullable/class types.
        if (destinationType is null)
            throw new InvalidOperationException("Destination type could not be determined.");
        
        var result = context.Mapper.Map(source.Value, typeof(T), destinationType);

        return result;
    }
}

Mapping configuration

CreateMap(typeof(Setting<>), typeof(object)).ConvertUsing(typeof(SettingToObjectConverter<>));
CreateMap<UpdateUser, CreateUser>();
CreateMap<UpdateAddress, CreateAddress>();

Version

11.0.1

Expected behavior

Converter could access types being mapped. This could be provided in Convert method as an argument or a property of ResolutionContext.

Using this converter, I'm not required to create map for every combination Setting -> U.

[lbargaoanu]

#3981

[tompetko]

Thanks for your reply but #3981 is not applicable in case of mapping to different type than underlying, like this: Setting<T>->U.

[lbargaoanu]

It does apply, you just need another operator. Otherwise, just pass a destination to Map or write a custom mapper for your case. See

cfg.Internal().Mappers.Insert(0, new EnumMapper());

[tompetko]

I'd prefer to put all mapping logic in one Profile, so writing another operator is no way to go, it's error prone.

What do you mean by passing destination to map? I'm mapping UpdateUser to CreateUser using mapper.Map<UpdateUser, CreateUser>(updateUser);. Problem occurs during Address property mapping from Setting<UpdateAddress> to Setting<CreateAddress>.

Writing custom ObjectMapper was the way to go, until I tried mapping Setting<DateTime?> to Setting<DateTime?>. NullableDestinationMapper was changing DateTime? to DateTime so my mapper had to be added as first.
If someone would be interrested in non-generic ObjectMapper, here it is:

SettingToObjectMapper

public sealed class SettingToObjectMapper : ObjectMapper
{
    public override bool IsMatch(TypePair context)
    {
        var isMatch = context.SourceType.IsGenericType && 
                      context.SourceType.GetGenericTypeDefinition() == typeof(Setting<>);

        return isMatch;
    }

    public override object Map(object source, object destination, Type sourceType, Type destinationType, ResolutionContext context)
    {
        Check.NotNull(source, nameof(source));

        var setting = (ISetting)source;

        var destinationValue = setting.Value != null ? 
            context.Mapper.Map(setting.Value, setting.ValueType, destinationType) : default;

        return destinationValue;
    }
}

Thanks @lbargaoanu for your time.

[lbargaoanu]

mapper.Map(source, destination);
And then smth like your initial code would work.