Автоматическое сопоставление двух объектов на основе условия

Question

Попытка выяснить, возможно ли в AutoMapper отобразить модели Customer и Address в список CustomerDetails, где значение ID в Customer соответствует CustomerID в адресе?

public class Customer {
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string Surname { get; set; }
}

public class Address {
    public int ID { get; set;}
    public int CustomerID { get; set; }
    public string Address1 { get; set; }
    public string Address2  { get; set; }
    public string Town { get; set; }
    public string PostCode { get; set; }
}

public class CustomerDetails{
    public int ID { get; set; }
    public Customer CustomerInfo { get; set; }
    public Address CustomerAddress { get; set; }
}

Конечная цель состоит в том, чтобы иметь следующий Json Объект

{
  ID: 1234,  
  CustomerInfo: {
      ID: 1,
      FirstName: "John",
      Surname: "Connor"   
  }
  CustomerAddress: {
      ID: 1232,
      CustomerID: 1,
      Address1: "123 Avenue",
      Address2: "Some road",
      Town: "London",
      PostCode: "L1WLL"
  }  
}

До сих пор я могу думать только о следующей конфигурации AutoMapper

Mapper.CreateMap<Customer, CustomerDetails>();
Mapper.CreateMap<Address, CustomerDetails>()

Использование

var mapping = Mapper.Map<CustomerDetails>(Customer)
                .Map(Address);

Answer 1

Вы можете объединить 2 коллекции в тип кортежа (Customer, Address) на основе идентификатора клиента и сопоставить этот тип с типом CustomerDetail.

CreateMap<(Customer cust, Address addr), CustomerDetails>();
customers.Select(r => (r, addresses.FirstOrDefault(a => a.CustomerID == r.ID))).Select(g => mapper.Map(g));

Вы также можете отобразить в два этапа, сначала сопоставьте клиентов с данными клиента, а затем сопоставьте адреса с данными клиента:

        CreateMap<Customer, CustomerDetails>()
            .ForMember(d => d.ID, opt => opt.MapFrom(s => s.ID))
            .ForMember(d => d.CustomerInfo, opt => opt.MapFrom(s => s))
            .ForAllOtherMembers(opt => opt.Ignore());

        CreateMap<Address, CustomerDetails>()
            .ForMember(d => d.CustomerAddress, opt => opt.MapFrom((s, d) => d.ID == s.CustomerID ? s : d.CustomerAddress))
            .ForAllOtherMembers(opt => opt.Ignore());

        CreateMap<Address, IEnumerable<CustomerDetails>>()
            .ConvertUsing((a, d, ctx) =>
            {
                CustomerDetails match = d.FirstOrDefault(c => c.ID == a.CustomerID);
                if (match != null) 
                {
                    ctx.Mapper.Map(match, a);
                }

                return d;
            });

Отображение:

List<Customer> customers = new List<Customer>();
List<Address> addresses = new List<Address>();
var result = mapper.Map<List<CustomerDetails>>(customers);
addresses.ForEach(a => mapper.Map(a, result));