How to map from a flat entity to more than one DTO?

Question

I'm wishing to use AutoMapper in C# .NET Core to map from an already flattened entity to a nested set of DTO's. Also the DTO’s have a one to many relationship, which the flattened entity is hiding in structure. For example:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Price { get; set; }
    public int Weight { get; set; }
}

public class ProductDto
{
    public string Name { get; set; }
    public IEnumerable<PriceDto> Prices { get; set; }
}

public class PriceDto
{
    public int Price { get; set; }
    public int Weight { get; set; }
}

I'm aware of the ReverseMap() function provided by AutoMapper, however given that I am starting with a flattened entity I'm not sure how set up the relationship between ProductDto and PriceDto.

EDIT: Here's an example set of the flattened data that I receive in the form of "Product". Notice the inferred one-to-many relationship between the ProductDto and PriceDto which will be needed.

+-----+-------+-------+--------+
| Id  | Name  | Price | Weight |
+-----+-------+-------+--------+
|   1 | "foo" |     8 |     12 |
|   2 | "foo" |    12 |     18 |
|   3 | "bar" |     3 |      1 |
|   4 | "bar" |     6 |      2 |
| ... |       |       |        |
+-----+-------+-------+--------+

Answer 1

You need to implement your own Converter like below:

1. ProductsConverter

   public class ProductsConverter : ITypeConverter<List<Product>, List<ProductDto>>
   {
       public List<ProductDto> Convert(List<Product> source, List<ProductDto> destination, ResolutionContext context)
       {
           return source.GroupBy(p => p.Name)
                       .Select(r => new ProductDto
                       {
                           Name = r.Key,
                           Prices =  source.Where(pp => pp.Name == r.Key)
                                                       .Select(rr => new PriceDto
                                                       {
                                                           Price = rr.Price,
                                                           Weight = rr.Weight
                                                       })
                       }).ToList();
       }
   }
   

2. ModelProfile

   public class ModelProfile: Profile
   {
       public ModelProfile()
       {
           CreateMap<List<Product>, List<ProductDto>>()
               .ConvertUsing<ProductsConverter>();
       }
   }
   

3. Use Case

   public IActionResult Index()
   {
       List<Product> products= new List<Product>() {
           new Product{ Id = 1, Name = "foo", Price = 8, Weight = 12},
           new Product{ Id = 2, Name = "foo", Price = 12, Weight = 18},
           new Product{ Id = 3, Name = "bar", Price = 3, Weight = 1},
           new Product{ Id = 4, Name = "bar", Price = 6, Weight = 2},
       };
       var result = _mapper.Map<List<ProductDto>>(products);
       return Ok(result);
   }
   

Answer 2

I would define two domain profiles. One for Product to ProductDto

CreateMap<Product, ProductDto>()
  .ForMember(x => x.Id , opts => opts.Ignore())
  .ForMember(x => x.Price , opts => opts.Ignore())
  .ForMember(x => x.Weight , opts => opts.Ignore())
  .ForMember(x => x.Name , opts => opts.MapFrom(y => y.Name));

And one for Product to PriceDto

CreateMap<Product, ProductDto>()
  .ForMember(x => x.Id , opts => opts.Ignore())
  .ForMember(x => x.Name , opts => opts.Ignore())
  .ForMember(x => x.Price , opts => opts.MapFrom(y => y.Price ))
  .ForMember(x => x.Weight , opts => opts.MapFrom(y => y.Weight ));

And then do one mapping at a time from same source to two different targets.