Flattening ignores explicit type mapping rules

Setup

I have an Entity object with Props collection.

class Entity
{
  public string Name { get; set; } = default!;
  public List<EntityProp> Props { get; set; } = default!;
}

class EntityProp
{
  public string Key { get; set; } = default!;
  public string Value { get; set; } = default!;
}

My goal is to map it into a Dto object where items from Props collections become properties of destination object.

class Dto
{
  public string Name { get; set; } = default!;
  public string? Address { get; set; }
  public string? Description { get; set; }
  public string? Phone { get; set; }
}

For versatility I have two mapping. First is to flatten the Props into destination root and second to configure Props mapping.

config.NewConfig<Entity, Dto>().Map(e => e, e => e.Props);
config.NewConfig<List<EntityProp>, Dto>()
  .Map(e => e.Address, e => e.Get("Address"))
  .Map(e => e.Description, e => e.Get("Description"))
  .Map(e => e.Phone, e => e.Get("Phone"));

Problem

Second mapping rules are not obeyed during conversion. Is this pattern valid? Any workaround?

Complete code sample

using System.Collections.Generic;
using System.Linq;
using Mapster;

class Entity
{
  public string Name { get; set; } = default!;
  public List<EntityProp> Props { get; set; } = default!;
}

class EntityProp
{
  public string Key { get; set; } = default!;
  public string Value { get; set; } = default!;
}

class Dto
{
  public string Name { get; set; } = default!;
  public string? Address { get; set; }
  public string? Description { get; set; }
  public string? Phone { get; set; }
}

static class TestMapster
{
  public static void Test()
  {
    TypeAdapterConfig config = new();
    config.NewConfig<Entity, Dto>().Map(e => e, e => e.Props);
    config.NewConfig<List<EntityProp>, Dto>()
      .Map(e => e.Address, e => e.Get("Address"))
      .Map(e => e.Description, e => e.Get("Description"))
      .Map(e => e.Phone, e => e.Get("Phone"));

    Entity ent = new()
    {
      Name = "My entity",
      Props = [
        new() { Key = "Phone", Value = "12345678" }
      ],
    };

    Dto dto = ent.Adapt<Dto>(config);

    // dto.Name is mapped correctly and equals to "My entity".
    // Expected dto.Phone to be equal to "12345678",
    // but it is not mapped and is null
  }
}

static class ListExtensions
{
  // utility method as expression bodies are not allowed to have null propagating operator
  public static string? Get(this List<EntityProp> list, string key)
    => list.FirstOrDefault(e => e.Key == key)?.Value;
}

The opposite (unflattening) ignores configuration too. I.e.

config.NewConfig<Dto, Entity>().Map(e => e.Props, e => e);
config.NewConfig<Dto, List<EntityProp>>().MapWith(/* */) // or .MapToTargetWith(/* */) // <-- IGNORED

feat(test): add revers type mapping test for MapsterMapper#980

@dcby

Hi, @dcby this is more likely Toplevel mapping from two sources at once, and apparently it was not supported for Custom mappings (Map). Flattening/Unflattening In my opinion, it's a little different..

@dcby What version of mapster are you using?

I think I've found a solution for at least this case, and it will be available in the next version of Mapster.

Now for your cases you need to use AfterMapping()

TypeAdapterConfig config = new();

        config.NewConfig<List<EntityProp>, Dto>()
          .Map(e => e.Address, e => e.Get("Address"))
          .Map(e => e.Description, e => e.Get("Description"))
          .Map(e => e.Phone, e => e.Get("Phone"));



        config.NewConfig<Entity, Dto>()
            .AfterMapping((src, dest, result) =>
            {
                    src.Props.Adapt(result ?? dest, config);
            });


    TypeAdapterConfig config = new();
    config.NewConfig<Entity980, Dto980>()
         .Map(e => e, e => ListExtensions980.GetProps()); // Explicit configuration other source
    config.NewConfig<List<EntityProp980>, Dto980>()
      .Map(e => e.Address, e => e.Get("Address"))
      .Map(e => e.Description, e => e.Get("Description"))
      .Map(e => e.Phone, e => e.Get("Phone"));

// First Source
Entity ent = new()

///Second source
public static class ListExtensions980
{
  
    public static List<EntityProp980> GetProps()
    {
        var result = new List<EntityProp980>();

        result.Add(new() { Key = "Phone", Value = "12345678" });
        result.Add(new() { Key = "Address", Value = "Default street" });
        result.Add(new() { Key = "Description", Value = "Sample text" });


        return result;
    }
}

@DocSvartz

@DocSvartz,

What version of mapster are you using?

It's 10.0.7 (the latest to the moment)

Now for your cases you need to use AfterMapping()

Yes, this is exactly what I'm doing now for both cases. But it feels "unnatural".

I think I've found a solution for at least this case, and it will be available in the next version of Mapster.

Thank you!

@dcby

Hi, @dcby this is more likely Toplevel mapping from two sources at once, and apparently it was not supported for Custom mappings (Map). Flattening/Unflattening In my opinion, it's a little different.

Let's call it Merging/Unmerging. Would be great to have first class support for it.

Navigation Menu

Repository navigation

Flattening ignores explicit type mapping rules #980

Setup

Problem

Complete code sample

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Flattening ignores explicit type mapping rules #980

Description

Setup

Problem

Complete code sample

Activity

dcby commented on May 28, 2026

DocSvartz commented on May 28, 2026

DocSvartz commented on May 28, 2026

dcby commented on May 28, 2026

dcby commented on May 28, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions